diff --git a/.github/workflows/benchmark.yaml b/.github/workflows/benchmark.yaml new file mode 100644 index 0000000..761ebb8 --- /dev/null +++ b/.github/workflows/benchmark.yaml @@ -0,0 +1,124 @@ +name: Pytest Benchmarks + +on: + pull_request: + branches: [master] + paths: + - '**.py' + - '.github/workflows/benchmark.yaml' + - 'pyproject.toml' + - 'setup.py' + push: + branches: [master] + paths: + - '**.py' + - '.github/workflows/benchmark.yaml' + - 'pyproject.toml' + - 'setup.py' + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + benchmark: + name: Run Benchmarks + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install .[dev] pytest-codspeed pytest-benchmark + - name: Remove Python files from test env + run: rm -r faster_hexbytes + - name: Run Pytest Benchmark & Save Output + run: pytest --benchmark-only --benchmark-json=benchmark.json benchmarks/ + - name: Upload Pytest Benchmark Results + uses: actions/upload-artifact@v4 + with: + name: pytest-benchmark-results + path: benchmark.json + - name: Parse Pytest Benchmark Output + run: python scripts/benchmark/parse_benchmark_output.py benchmark.json pytest_benchmark_results.json + - name: Compare Pytest Benchmark Results + run: python scripts/benchmark/compare_benchmark_results.py pytest_benchmark_results.json pytest_benchmark_diff.json + - name: Generate Markdown Benchmark Results + run: python scripts/benchmark/generate_benchmark_markdown.py + - name: Commit and Push Markdown Benchmark Results + continue-on-error: true + run: | + git config --global user.name "github-actions[bot]" + git config --global user.email "github-actions[bot]@users.noreply.github.com" + git fetch origin ${{ github.head_ref || github.ref_name }} + git checkout ${{ github.head_ref || github.ref_name }} + git add benchmarks/results/*.md + if git diff --cached --quiet; then + echo "No changes to commit." + else + git commit -m "Update benchmark results [skip ci]" + git push origin HEAD:${{ github.head_ref || github.ref_name }} + fi + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + - name: Upload Markdown Benchmark Results + uses: actions/upload-artifact@v4 + with: + name: markdown-benchmark-results + path: benchmarks/results/*.md + - name: Upload Pytest Benchmark Diff + uses: actions/upload-artifact@v4 + with: + name: pytest-benchmark-diff + path: pytest_benchmark_diff.json + - name: Post Pytest Benchmark Diff as PR Comment + uses: actions/github-script@v7 + with: + script: | + const fs = require('fs'); + const diff = JSON.parse(fs.readFileSync('pytest_benchmark_diff.json', 'utf8')); + let body = '### Pytest Benchmark Diff\n\n'; + const repo = `${context.repo.owner}/${context.repo.repo}`; + const branch = context.payload.pull_request ? context.payload.pull_request.head.ref : context.ref.replace('refs/heads/', ''); + for (const [submodule, groupDiffs] of Object.entries(diff)) { + let submoduleFile = "unknown"; + let benchmarkFile = "unknown"; + const m = submodule.match(/^faster_hexbytes\.(.+)$/); + if (m) { + submoduleFile = `faster_hexbytes/${m[1]}.py`; + benchmarkFile = `benchmarks/test_${m[1]}_benchmarks.py`; + } + const submoduleUrl = `https://github.com/${repo}/blob/${branch}/${submoduleFile}`; + const benchmarkUrl = `https://github.com/${repo}/blob/${branch}/${benchmarkFile}`; + body += `#### [${submodule}](${submoduleUrl}) - [view benchmarks](${benchmarkUrl})\n`; + body += '| Function | Reference Mean | Faster Mean | % Change | Speedup (%) | x Faster | Faster |\n'; + body += '|----------|---------------|-------------|----------|-------------|----------|--------|\n'; + for (const [group, data] of Object.entries(groupDiffs).sort(([a], [b]) => a.localeCompare(b))) { + if (data.percent_change !== null && data.percent_change !== undefined) { + let emoji = '➖'; + if (data.percent_change > 0) emoji = '✅'; + else if (data.percent_change < 0) emoji = '❌'; + const percentChange = data.percent_change !== undefined && data.percent_change !== null + ? `${data.percent_change.toFixed(2)}%` : ''; + const speedupPercent = data.speedup_percent !== undefined && data.speedup_percent !== null + ? `${data.speedup_percent.toFixed(2)}%` : ''; + const speedupX = data.speedup_x !== undefined && data.speedup_x !== null && isFinite(data.speedup_x) + ? `${data.speedup_x.toFixed(2)}x` : ''; + body += `| \`${group}\` | ${data.reference_mean} | ${data.faster_mean} | ${percentChange} | ${speedupPercent} | ${speedupX} | ${emoji} |\n`; + } else if (data.note) { + body += `| \`${group}\` | | | | | | ➖ |\n`; + } + } + body += '\n'; + } + github.rest.issues.createComment({ + ...context.repo, + issue_number: context.issue.number, + body + }); + if: github.event_name == 'pull_request' diff --git a/.github/workflows/codspeed.yaml b/.github/workflows/codspeed.yaml new file mode 100644 index 0000000..621dc47 --- /dev/null +++ b/.github/workflows/codspeed.yaml @@ -0,0 +1,43 @@ +name: CodSpeed Benchmarks + +on: + pull_request: + branches: [master] + paths: + - '**.py' + - '.github/workflows/codspeed.yaml' + - 'pyproject.toml' + - 'setup.py' + push: + branches: [master] + paths: + - '**.py' + - '.github/workflows/codspeed.yaml' + - 'pyproject.toml' + - 'setup.py' + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + benchmark: + name: Run CodSpeed Benchmarks + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install .[dev] pytest-codspeed + - name: Remove Python files from test env + run: rm -r faster_hexbytes + - name: Run CodSpeed + uses: CodSpeedHQ/action@v3 + with: + run: pytest --codspeed -k "test_faster_" benchmarks/ diff --git a/.github/workflows/compile.yaml b/.github/workflows/compile.yaml new file mode 100644 index 0000000..7f0ffcd --- /dev/null +++ b/.github/workflows/compile.yaml @@ -0,0 +1,70 @@ +name: Compile + +on: + pull_request: + branches: + - master + paths-ignore: + - '.github/workflows/**' + - '!.github/workflows/compile.yaml' + push: + branches: + - master + paths-ignore: + - '.github/workflows/**' + - '!.github/workflows/compile.yaml' + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-ubuntu: + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v3 + with: + # Check out the PR branch + ref: ${{ github.head_ref }} + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install Faster Hexbytes + env: + MYPYC_STRICT_DUNDER_TYPING: 1 + run: pip install . + + - name: Normalize C files for diffchecking + # This makes it much easier to diffcheck changes in the C files + run: | + # Insert DIFFCHECK_PLACEHOLDER macro at the top if not present + for f in build/*.c; do + if ! grep -q 'DIFFCHECK_PLACEHOLDER' "$f"; then + sed -i '1i#ifndef DIFFCHECK_PLACEHOLDER\n#define DIFFCHECK_PLACEHOLDER 0\n#endif' "$f" + fi + done + # Replace line number in CPy_AddTraceback with macro + sed -i 's/\(CPy_AddTraceback([^,]*, *[^,]*, *\)[0-9]\+\(, *[^)]*)\)/\1DIFFCHECK_PLACEHOLDER\2/g' build/*.c + # Replace index in CPyStatics[...] with macro + sed -i 's/CPyStatics\[[0-9]\+\]/CPyStatics[DIFFCHECK_PLACEHOLDER]/g' build/*.c + + - name: Check for changes + run: | + if [[ -n $(git status --porcelain) ]]; then + echo "changes_detected=true" >> $GITHUB_ENV + else + echo "changes_detected=false" >> $GITHUB_ENV + fi + + - name: Commit changes + if: env.changes_detected == 'true' + run: | + git config --local user.name "github-actions[bot]" + git config --local user.email "github-actions[bot]@users.noreply.github.com" + git add . + git commit -m "chore: compile C files for source control" + git push diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml new file mode 100644 index 0000000..4cb1a77 --- /dev/null +++ b/.github/workflows/release.yaml @@ -0,0 +1,199 @@ +name: Build and Publish Wheels + +on: + release: + branches: + - master + types: [published] + +jobs: + build_wheels: + name: Build wheels using cibuildwheel + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + # ---------------------------------------------------- + # manylinux 64-bit + # ---------------------------------------------------- + - os: ubuntu-latest + build_type: manylinux-x64 + cibw_build: "*manylinux*" + cibw_archs_linux: x86_64 + artifact_name: "wheels-ubuntu-latest-manylinux-x64" + + # ---------------------------------------------------- + # manylinux 32-bit + # ---------------------------------------------------- + - os: ubuntu-latest + build_type: manylinux-x86 + cibw_build: "*manylinux*" + cibw_archs_linux: i686 + artifact_name: "wheels-ubuntu-latest-manylinux-x86" + + # ---------------------------------------------------- + # musllinux 64-bit + # ---------------------------------------------------- + - os: ubuntu-latest + build_type: musllinux-x64 + cibw_build: "*musllinux*" + cibw_archs_linux: x86_64 + artifact_name: "wheels-ubuntu-latest-musllinux-x64" + + # ---------------------------------------------------- + # musllinux 32-bit + # ---------------------------------------------------- + - os: ubuntu-latest + build_type: musllinux-x86 + cibw_build: "*musllinux*" + cibw_archs_linux: i686 + artifact_name: "wheels-ubuntu-latest-musllinux-x86" + + # ---------------------------------------------------- + # macOS (64-bit only) + # ---------------------------------------------------- + - os: macos-latest + build_type: macos + cibw_build: "" + cibw_archs_linux: "" + artifact_name: "wheels-macos-latest" + + # ---------------------------------------------------- + # Windows 64-bit + # ---------------------------------------------------- + - os: windows-latest + build_type: winx64 + cibw_build: "" + cibw_archs_windows: AMD64 + artifact_name: "wheels-windows-latest-x64" + + # ---------------------------------------------------- + # Windows 32-bit + # ---------------------------------------------------- + - os: windows-latest + build_type: winx86 + cibw_build: "" + cibw_archs_windows: x86 + artifact_name: "wheels-windows-latest-x86" + + steps: + - name: Check out code + uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: "3.11" + + - name: Install cibuildwheel + run: | + python -m pip install --upgrade pip setuptools wheel cibuildwheel + + - name: Build wheels + env: + # Skip PyPy + CIBW_SKIP: pp* + # On Linux: manylinux / musllinux arches + CIBW_ARCHS_LINUX: ${{ matrix.cibw_archs_linux || '' }} + # On Windows: AMD64 / x86 + CIBW_ARCHS_WINDOWS: ${{ matrix.cibw_archs_windows || '' }} + # Which wheels to build for Linux (manylinux vs. musllinux) + CIBW_BUILD: ${{ matrix.cibw_build || '' }} + run: | + python -m cibuildwheel --output-dir wheelhouse + + - name: Upload wheels + uses: actions/upload-artifact@v4 + with: + name: ${{ matrix.artifact_name }} + path: wheelhouse/*.whl + + publish_sdist_and_wheels: + name: Publish wheels to PyPI + needs: build_wheels + runs-on: ubuntu-latest + steps: + - name: Check out code + uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: "3.11" + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install setuptools wheel twine mypy==1.18.2 hexbytes==1.3.1 + + - name: Build sdist + run: | + python setup.py sdist + + # ---------------------------------------------------- + # Download wheels built on each runner + # ---------------------------------------------------- + - name: Download manylinux 64-bit wheels + uses: actions/download-artifact@v4 + with: + name: "wheels-ubuntu-latest-manylinux-x64" + path: wheelhouse/linux-many-x64 + + - name: Download manylinux 32-bit wheels + uses: actions/download-artifact@v4 + with: + name: "wheels-ubuntu-latest-manylinux-x86" + path: wheelhouse/linux-many-x86 + + - name: Download musllinux 64-bit wheels + uses: actions/download-artifact@v4 + with: + name: "wheels-ubuntu-latest-musllinux-x64" + path: wheelhouse/linux-musl-x64 + + - name: Download musllinux 32-bit wheels + uses: actions/download-artifact@v4 + with: + name: "wheels-ubuntu-latest-musllinux-x86" + path: wheelhouse/linux-musl-x86 + + - name: Download macOS wheels + uses: actions/download-artifact@v4 + with: + name: "wheels-macos-latest" + path: wheelhouse/macos + + - name: Download Windows 64-bit wheels + uses: actions/download-artifact@v4 + with: + name: "wheels-windows-latest-x64" + path: wheelhouse/windows-x64 + + - name: Download Windows 32-bit wheels + uses: actions/download-artifact@v4 + with: + name: "wheels-windows-latest-x86" + path: wheelhouse/windows-x86 + + # ---------------------------------------------------- + # Publish all built artifacts to PyPI + # ---------------------------------------------------- + - name: Publish sdist and wheels to PyPI + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} + run: | + twine upload \ + dist/* \ + wheelhouse/linux-many-x64/*.whl \ + wheelhouse/linux-many-x86/*.whl \ + wheelhouse/linux-musl-x64/*.whl \ + wheelhouse/linux-musl-x86/*.whl \ + wheelhouse/macos/*.whl \ + wheelhouse/windows-x64/*.whl \ + wheelhouse/windows-x86/*.whl diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml new file mode 100644 index 0000000..45ca152 --- /dev/null +++ b/.github/workflows/tox.yaml @@ -0,0 +1,61 @@ +name: Tox + +on: + push: + branches: [main, master] + paths: + - '**.py' + - '.github/workflows/benchmark.yaml' + - 'pyproject.toml' + - 'setup.py' + pull_request: + branches: [main, master] + paths: + - '**.py' + - '.github/workflows/benchmark.yaml' + - 'pyproject.toml' + - 'setup.py' + schedule: + - cron: '0 12 * * 1-5' # Weekdays 12:00 UTC + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + test: + name: Test (${{ matrix.jobtype }}, ${{ matrix.python-version}}, ${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"] + jobtype: [core, lint, wheel] + env: + TOXENV: py${{ matrix.python-version }}-${{ matrix.jobtype }} + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + + - name: Upgrade pip and install tox + run: | + python -m pip install --upgrade pip + python -m pip install tox + + - name: Cache tox, pip, and hypothesis + uses: actions/cache@v4 + with: + path: | + .tox + .hypothesis + ~/.cache/pip + ~/.local + key: ${{ runner.os }}-tox-${{ matrix.python-version }}-${{ matrix.jobtype }}-${{ hashFiles('setup.py', 'tox.ini') }} + + - name: Run tox + run: python -m tox run -r diff --git a/.gitignore b/.gitignore index 2eb3d43..85311be 100644 --- a/.gitignore +++ b/.gitignore @@ -7,7 +7,9 @@ *.egg *.egg-info dist -build +build/**/*.py +build/**/*.typed +build/**/*.o .build eggs .eggs diff --git a/README.md b/README.md index c7e0ade..d9c368e 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,17 @@ +### I forked hexbytes and compiled it to C. It does the same stuff, now faster + +[![PyPI](https://img.shields.io/pypi/v/faster-hexbytes.svg?logo=Python&logoColor=white)](https://pypi.org/project/faster-hexbytes/) +[![Monthly Downloads](https://img.shields.io/pypi/dm/faster-hexbytes)](https://pypistats.org/packages/faster-hexbytes) +[![Codspeed.io Status](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/BobTheBuidler/faster-hexbytes) + +##### This fork will be kept up-to-date with [hexbytes](https://github.com/ethereum/hexbytes). I will pull updates as they are released and push new [faster-hexbytes](https://github.com/BobTheBuidler/faster-hexbytes) releases to [PyPI](https://pypi.org/project/faster-hexbytes/). + +##### You can find the compiled C code on faster-hexbytes [master](https://github.com/BobTheBuidler/hexbytes/tree/master) branch. + +##### We benchmark `faster-hexbytes` against the original `hexbytes` for your convenience. [See results](https://github.com/BobTheBuidler/faster-hexbytes/tree/master/benchmarks/results). + +##### The original hexbytes readme is below: + # HexBytes [![Join the conversation on Discord](https://img.shields.io/discord/809793915578089484?color=blue&label=chat&logo=discord&logoColor=white)](https://discord.gg/GHryRvPB84) diff --git a/benchmarks/__init__.py b/benchmarks/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/benchmarks/__init__.py @@ -0,0 +1 @@ + diff --git a/benchmarks/params.py b/benchmarks/params.py new file mode 100644 index 0000000..7784144 --- /dev/null +++ b/benchmarks/params.py @@ -0,0 +1,193 @@ +from typing import Any, List, Tuple, Union +from eth_typing import HexStr + +import hexbytes +import faster_hexbytes + +Convertable = Union[bool, bytearray, bytes, int, str, memoryview] + +# Centralized list of all byte patterns and their ids (use human-readable where possible) +BYTES_CASES: List[Tuple[bytes, str]] = [ + (b"abc", "b'abc'"), + (b"", "b''"), + (b"\x00" * 32, "b'\\x00'*32"), + (b"\xff" * 64, "b'\\xff'*64"), + (b"a" * 1024, "b'a'*1024"), + (b"\x01\x02\x03", "b'\\x01\\x02\\x03'"), + (b"\xde\xad\xbe\xef", "b'\\xde\\xad\\xbe\\xef'"), + (b"\x00\xff\x00\xff", "b'\\x00\\xff\\x00\\xff'"), + (b"palindromeemordnilap", "palindrome"), + (b"\x7f" * 8, "b'\\x7f'*8"), + (b"\x80" * 8, "b'\\x80'*8"), + (b"\x01" * 100, "b'\\x01'*100"), + (b"\x10\x20\x30\x40\x50", "b'\\x10\\x20\\x30\\x40\\x50'"), + (b"\x00\xff" * 32, "alternating 0x00/0xff"), + (b"\xaa\x55" * 32, "alternating 0xaa/0x55"), + (b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09", "0-9"), + (b"\x00\x10\x20\x30\x40\x50\x60\x70\x80\x90", "multiples of 0x10"), + (b"\x01" * 2048, "b'\\x01'*2048"), + (b"\x00\x01" * 512, "long alternating"), + (b"\x00\xff\x01\xfe" * 64, "4-byte pattern"), + (bytes(range(256)), "all byte values"), + (b"racecar", "palindrome ascii"), + (b"12321", "palindrome numeric"), + (b"\x00" * 1, "single null byte"), + (b"\xff" * 1, "single 0xff"), + (b"\x01\x02" * 50 + b"\x03\x04" * 50, "mixed pattern"), + (b"\x00\xff" * 16 + b"\x01\xfe" * 16, "two patterns"), + (b"the quick brown fox jumps over the lazy dog", "ascii sentence"), + (b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09" * 10, "repeated 0-9"), +] + +BYTES_VALS: List[bytes] = [v for v, _ in BYTES_CASES] +BYTES_IDS: List[str] = [id for _, id in BYTES_CASES] + + +def variant_ids(base_ids: List[str], prefix: str) -> List[str]: + return [f"{prefix}({id})" for id in base_ids] + + +BYTEARRAYS = [bytearray(b) for b in BYTES_VALS] +BYTEARRAYS_IDS = variant_ids(BYTES_IDS, "bytearray") + +MEMORYVIEWS = [memoryview(b) for b in BYTES_VALS] +MEMORYVIEWS_IDS = variant_ids(BYTES_IDS, "memoryview") + +HEXBYTES_ORIG = [hexbytes.HexBytes(b) for b in BYTES_VALS] +HEXBYTES_ORIG_IDS = variant_ids(BYTES_IDS, "hexbytes.HexBytes") + +HEXBYTES_FAST = [faster_hexbytes.HexBytes(b) for b in BYTES_VALS] +HEXBYTES_FAST_IDS = variant_ids(BYTES_IDS, "faster_hexbytes.HexBytes") + +# Other types for construction and conversion, with human-readable ids where possible +STR_CASES: List[Tuple[str, str]] = [ + ("abc", "'abc'"), + ("", "''"), + ("0x1234", "'0x1234'"), + ("deadbeef", "'deadbeef'"), + ("0x", "'0x'"), + ("0x" + "ff" * 32, "'0x'+'ff'*32"), + ("0x" + "00" * 64, "'0x'+'00'*64"), + ("0xabcdef", "'0xabcdef'"), + ("0x" + "a" * 128, "'0x'+'a'*128"), + ("0xdeadbeef", "'0xdeadbeef'"), + ("0xCAFEBABE", "'0xCAFEBABE'"), +] +STR_VALS: List[str] = [v for v, _ in STR_CASES] +STR_IDS: List[str] = [id for _, id in STR_CASES] + +INT_CASES: List[Tuple[int, str]] = [ + (123456, "123456"), + (0, "0"), + (2**8, "2**8"), + (2**16, "2**16"), + (2**32, "2**32"), + (2**64, "2**64"), + (2**256 - 1, "2**256-1"), +] +INT_VALS: List[int] = [v for v, _ in INT_CASES] +INT_IDS: List[str] = [id for _, id in INT_CASES] + +BOOL_CASES: List[Tuple[bool, str]] = [ + (True, "True"), + (False, "False"), +] +BOOL_VALS: List[bool] = [v for v, _ in BOOL_CASES] +BOOL_IDS: List[str] = [id for _, id in BOOL_CASES] + +# For to_bytes and HexBytes construction +CONSTRUCTOR_VALS: List[Any] = ( + BYTES_VALS + BYTEARRAYS + MEMORYVIEWS + STR_VALS + INT_VALS + BOOL_VALS +) +CONSTRUCTOR_IDS: List[str] = ( + BYTES_IDS + BYTEARRAYS_IDS + MEMORYVIEWS_IDS + STR_IDS + INT_IDS + BOOL_IDS +) + +# For bytes-based operations +# (BYTES_VALS and BYTES_IDS already defined above) + +# For index and slice operations +INDEXES = [0, 1, 2, 3, 4, 5, -1] +INDEX_IDS = [str(i) for i in INDEXES] + +SLICES = [slice(0, 3), slice(1, 6), slice(2, None), slice(None, None), slice(-3, None)] +SLICE_IDS = [ + "slice(0,3)", + "slice(1,6)", + "slice(2,None)", + "slice(None,None)", + "slice(-3,None)", +] + +# For to_bytes and hexstr_to_bytes +TO_BYTES_VALS: List[Convertable] = ( + BYTES_VALS + BYTEARRAYS + MEMORYVIEWS + STR_VALS + INT_VALS + BOOL_VALS +) +TO_BYTES_IDS: List[str] = ( + BYTES_IDS + BYTEARRAYS_IDS + MEMORYVIEWS_IDS + STR_IDS + INT_IDS + BOOL_IDS +) + +HEXSTRINGS: List[HexStr] = [ + "0x1234", + "deadbeef", + "0x", + "", + "0x" + "ff" * 32, + "0x" + "00" * 64, + "0xabcdef", + "0x" + "a" * 128, + "0xdeadbeef", + "0xCAFEBABE", + "0x0", + "0x1", + "0x" + "1" * 64, + "0x" + "f" * 64, + "0x" + "0" * 128, + "0x" + "1234567890abcdef" * 8, + "0x" + "00ff" * 16, + "0x" + "ff00" * 16, + "0x" + "a1b2c3d4" * 8, + "0x" + "dead" * 16, + "0x" + "beef" * 16, + "0x" + "cafebabe" * 8, + "0x" + "facefeed" * 8, + "0x" + "badc0ffee0ddf00d" * 4, + "0x" + "0123456789abcdef" * 8, + "0x" + "f" * 128, + "0x" + "e" * 256, + "0x" + "d" * 512, + "0x" + "c" * 1024, + "0x" + "b" * 2048, +] +HEXSTRINGS_IDS: List[str] = [ + "'0x1234'", + "'deadbeef'", + "'0x'", + "''", + "'0x'+'ff'*32", + "'0x'+'00'*64", + "'0xabcdef'", + "'0x'+'a'*128", + "'0xdeadbeef'", + "'0xCAFEBABE'", + "'0x0'", + "'0x1'", + "'0x'+'1'*64", + "'0x'+'f'*64", + "'0x'+'0'*128", + "'0x'+'1234567890abcdef'*8", + "'0x'+'00ff'*16", + "'0x'+'ff00'*16", + "'0x'+'a1b2c3d4'*8", + "'0x'+'dead'*16", + "'0x'+'beef'*16", + "'0x'+'cafebabe'*8", + "'0x'+'facefeed'*8", + "'0x'+'badc0ffee0ddf00d'*4", + "'0x'+'0123456789abcdef'*8", + "'0x'+'f'*128", + "'0x'+'e'*256", + "'0x'+'d'*512", + "'0x'+'c'*1024", + "'0x'+'b'*2048", +] diff --git a/benchmarks/results/_utils.md b/benchmarks/results/_utils.md new file mode 100644 index 0000000..558a7fa --- /dev/null +++ b/benchmarks/results/_utils.md @@ -0,0 +1,141 @@ +#### [faster_hexbytes._utils](https://github.com/BobTheBuidler/faster-hexbytes/blob/master/faster_hexbytes/_utils.py) - [view benchmarks](https://github.com/BobTheBuidler/faster-hexbytes/blob/master/benchmarks/test__utils_benchmarks.py) + +| Function | Reference Mean | Faster Mean | % Change | Speedup (%) | x Faster | Faster | +|----------|---------------|-------------|----------|-------------|----------|--------| +| `hexstr_to_bytes['']` | 1.8448173054630068e-05 | 1.1081327282258675e-05 | 39.93% | 66.48% | 1.66x | ✅ | +| `hexstr_to_bytes['0x'+'0'*128]` | 3.5010302596263576e-05 | 2.1963078559743485e-05 | 37.27% | 59.41% | 1.59x | ✅ | +| `hexstr_to_bytes['0x'+'00'*64]` | 3.5872280479722826e-05 | 2.1835577381899273e-05 | 39.13% | 64.28% | 1.64x | ✅ | +| `hexstr_to_bytes['0x'+'00ff'*16]` | 3.207654558679734e-05 | 1.869541155559719e-05 | 41.72% | 71.57% | 1.72x | ✅ | +| `hexstr_to_bytes['0x'+'0123456789abcdef'*8]` | 3.4987447867315116e-05 | 2.178945236948726e-05 | 37.72% | 60.57% | 1.61x | ✅ | +| `hexstr_to_bytes['0x'+'1'*64]` | 3.2389060060779915e-05 | 1.8501119211229607e-05 | 42.88% | 75.07% | 1.75x | ✅ | +| `hexstr_to_bytes['0x'+'1234567890abcdef'*8]` | 3.444874510553207e-05 | 2.1502671017062903e-05 | 37.58% | 60.21% | 1.60x | ✅ | +| `hexstr_to_bytes['0x'+'a'*128]` | 3.5264738009439144e-05 | 2.158244799088343e-05 | 38.80% | 63.40% | 1.63x | ✅ | +| `hexstr_to_bytes['0x'+'a1b2c3d4'*8]` | 3.2396264056787564e-05 | 1.8735612379785145e-05 | 42.17% | 72.91% | 1.73x | ✅ | +| `hexstr_to_bytes['0x'+'b'*2048]` | 0.0001398787403252671 | 0.0001236088855531614 | 11.63% | 13.16% | 1.13x | ✅ | +| `hexstr_to_bytes['0x'+'badc0ffee0ddf00d'*4]` | 3.2141636095463136e-05 | 1.8578952246858088e-05 | 42.20% | 73.00% | 1.73x | ✅ | +| `hexstr_to_bytes['0x'+'beef'*16]` | 3.125322299956043e-05 | 1.847773134031433e-05 | 40.88% | 69.14% | 1.69x | ✅ | +| `hexstr_to_bytes['0x'+'c'*1024]` | 9.174784195341271e-05 | 7.372294570322513e-05 | 19.65% | 24.45% | 1.24x | ✅ | +| `hexstr_to_bytes['0x'+'cafebabe'*8]` | 3.206340673007434e-05 | 1.860500047978184e-05 | 41.97% | 72.34% | 1.72x | ✅ | +| `hexstr_to_bytes['0x'+'d'*512]` | 5.873433669224578e-05 | 4.221991293357004e-05 | 28.12% | 39.12% | 1.39x | ✅ | +| `hexstr_to_bytes['0x'+'dead'*16]` | 3.180377264061887e-05 | 1.8717742330490115e-05 | 41.15% | 69.91% | 1.70x | ✅ | +| `hexstr_to_bytes['0x'+'e'*256]` | 4.4382508443150276e-05 | 2.855283578799186e-05 | 35.67% | 55.44% | 1.55x | ✅ | +| `hexstr_to_bytes['0x'+'f'*128]` | 3.495303635696786e-05 | 2.1718649302139505e-05 | 37.86% | 60.94% | 1.61x | ✅ | +| `hexstr_to_bytes['0x'+'f'*64]` | 3.2189130050460675e-05 | 1.8570359597155347e-05 | 42.31% | 73.34% | 1.73x | ✅ | +| `hexstr_to_bytes['0x'+'facefeed'*8]` | 3.1915963751809865e-05 | 1.8586999385518e-05 | 41.76% | 71.71% | 1.72x | ✅ | +| `hexstr_to_bytes['0x'+'ff'*32]` | 3.1905875591085456e-05 | 1.872841641170212e-05 | 41.30% | 70.36% | 1.70x | ✅ | +| `hexstr_to_bytes['0x'+'ff00'*16]` | 3.2106684891321425e-05 | 1.869685182626014e-05 | 41.77% | 71.72% | 1.72x | ✅ | +| `hexstr_to_bytes['0x']` | 2.2841874514238e-05 | 1.070881031847781e-05 | 53.12% | 113.30% | 2.13x | ✅ | +| `hexstr_to_bytes['0x0']` | 3.219212926666915e-05 | 1.9252426841545055e-05 | 40.20% | 67.21% | 1.67x | ✅ | +| `hexstr_to_bytes['0x1']` | 3.1901743141036275e-05 | 1.8980112380918578e-05 | 40.50% | 68.08% | 1.68x | ✅ | +| `hexstr_to_bytes['0x1234']` | 2.9499241468315646e-05 | 1.6726659333468447e-05 | 43.30% | 76.36% | 1.76x | ✅ | +| `hexstr_to_bytes['0xCAFEBABE']` | 2.9741717442893304e-05 | 1.6433473688372215e-05 | 44.75% | 80.98% | 1.81x | ✅ | +| `hexstr_to_bytes['0xabcdef']` | 2.9782669488161317e-05 | 1.62653914218193e-05 | 45.39% | 83.10% | 1.83x | ✅ | +| `hexstr_to_bytes['0xdeadbeef']` | 2.9666457610410784e-05 | 1.640743453376295e-05 | 44.69% | 80.81% | 1.81x | ✅ | +| `hexstr_to_bytes['deadbeef']` | 2.2690808462857158e-05 | 1.4418166275825207e-05 | 36.46% | 57.38% | 1.57x | ✅ | +| `to_bytes['']` | 2.865643236061303e-05 | 1.2222655397417577e-05 | 57.35% | 134.45% | 2.34x | ✅ | +| `to_bytes['0x'+'00'*64]` | 4.8784657924300516e-05 | 2.341495978085352e-05 | 52.00% | 108.35% | 2.08x | ✅ | +| `to_bytes['0x'+'a'*128]` | 4.8496313290994355e-05 | 2.2836847571904974e-05 | 52.91% | 112.36% | 2.12x | ✅ | +| `to_bytes['0x'+'ff'*32]` | 4.386399464230912e-05 | 1.9831429689361942e-05 | 54.79% | 121.18% | 2.21x | ✅ | +| `to_bytes['0x']` | 3.411775089291513e-05 | 1.2469393681146973e-05 | 63.45% | 173.61% | 2.74x | ✅ | +| `to_bytes['0x1234']` | 4.0758243663260276e-05 | 1.7902721023036014e-05 | 56.08% | 127.67% | 2.28x | ✅ | +| `to_bytes['0xCAFEBABE']` | 4.150746846565401e-05 | 1.7776359062763724e-05 | 57.17% | 133.50% | 2.33x | ✅ | +| `to_bytes['0xabcdef']` | 4.137074395266492e-05 | 1.7867306827215806e-05 | 56.81% | 131.54% | 2.32x | ✅ | +| `to_bytes['0xdeadbeef']` | 4.052291114368097e-05 | 1.7808346038185112e-05 | 56.05% | 127.55% | 2.28x | ✅ | +| `to_bytes['abc']` | 3.725041229930926e-05 | 1.9893637376178685e-05 | 46.59% | 87.25% | 1.87x | ✅ | +| `to_bytes['deadbeef']` | 3.28707727173849e-05 | 1.5747286292947015e-05 | 52.09% | 108.74% | 2.09x | ✅ | +| `to_bytes[0-9]` | 6.392680429027989e-06 | 3.6665572175734814e-06 | 42.64% | 74.35% | 1.74x | ✅ | +| `to_bytes[0]` | 7.474990538374166e-05 | 3.1264307007406345e-05 | 58.17% | 139.09% | 2.39x | ✅ | +| `to_bytes[123456]` | 8.031723937717636e-05 | 3.583260732121917e-05 | 55.39% | 124.15% | 2.24x | ✅ | +| `to_bytes[2**16]` | 7.867131007941883e-05 | 3.543881033746167e-05 | 54.95% | 121.99% | 2.22x | ✅ | +| `to_bytes[2**256-1]` | 8.307037388319841e-05 | 3.999529664536154e-05 | 51.85% | 107.70% | 2.08x | ✅ | +| `to_bytes[2**32]` | 8.138002992487582e-05 | 3.768455911305675e-05 | 53.69% | 115.95% | 2.16x | ✅ | +| `to_bytes[2**64]` | 8.428159123745304e-05 | 3.936584078727712e-05 | 53.29% | 114.10% | 2.14x | ✅ | +| `to_bytes[2**8]` | 7.809924869950352e-05 | 3.4441774366024405e-05 | 55.90% | 126.76% | 2.27x | ✅ | +| `to_bytes[4-byte pattern]` | 6.431185549605626e-06 | 3.5980801152854216e-06 | 44.05% | 78.74% | 1.79x | ✅ | +| `to_bytes[False]` | 2.2332413291133547e-05 | 4.182064017718794e-06 | 81.27% | 434.00% | 5.34x | ✅ | +| `to_bytes[True]` | 2.1212508048572107e-05 | 4.396064199077823e-06 | 79.28% | 382.53% | 4.83x | ✅ | +| `to_bytes[all byte values]` | 6.4051107715197005e-06 | 3.659983388573715e-06 | 42.86% | 75.00% | 1.75x | ✅ | +| `to_bytes[alternating 0x00/0xff]` | 6.291576331053291e-06 | 3.588196285281199e-06 | 42.97% | 75.34% | 1.75x | ✅ | +| `to_bytes[alternating 0xaa/0x55]` | 6.194616538288459e-06 | 3.6003222282648873e-06 | 41.88% | 72.06% | 1.72x | ✅ | +| `to_bytes[ascii sentence]` | 6.235820939835287e-06 | 3.6054959932631564e-06 | 42.18% | 72.95% | 1.73x | ✅ | +| `to_bytes[b'']` | 6.247750855499567e-06 | 3.5606263584800245e-06 | 43.01% | 75.47% | 1.75x | ✅ | +| `to_bytes[b'\\x00'*32]` | 6.248676519153925e-06 | 3.3745443494729644e-06 | 46.00% | 85.17% | 1.85x | ✅ | +| `to_bytes[b'\\x00\\xff\\x00\\xff']` | 6.26840453637847e-06 | 3.5393130577618807e-06 | 43.54% | 77.11% | 1.77x | ✅ | +| `to_bytes[b'\\x01'*100]` | 6.336584323221155e-06 | 3.5939162551217587e-06 | 43.28% | 76.31% | 1.76x | ✅ | +| `to_bytes[b'\\x01'*2048]` | 6.390587741813924e-06 | 3.603225833318425e-06 | 43.62% | 77.36% | 1.77x | ✅ | +| `to_bytes[b'\\x01\\x02\\x03']` | 6.277859385984753e-06 | 3.6065595523320303e-06 | 42.55% | 74.07% | 1.74x | ✅ | +| `to_bytes[b'\\x10\\x20\\x30\\x40\\x50']` | 6.301466782496292e-06 | 3.4131452737215008e-06 | 45.84% | 84.62% | 1.85x | ✅ | +| `to_bytes[b'\\x7f'*8]` | 6.103761197689352e-06 | 3.5084465223527928e-06 | 42.52% | 73.97% | 1.74x | ✅ | +| `to_bytes[b'\\x80'*8]` | 6.345391992893792e-06 | 3.6846543980723536e-06 | 41.93% | 72.21% | 1.72x | ✅ | +| `to_bytes[b'\\xde\\xad\\xbe\\xef']` | 6.486572866741052e-06 | 3.667832499695979e-06 | 43.46% | 76.85% | 1.77x | ✅ | +| `to_bytes[b'\\xff'*64]` | 6.220489174384481e-06 | 3.589998349570086e-06 | 42.29% | 73.27% | 1.73x | ✅ | +| `to_bytes[b'a'*1024]` | 6.322454795164475e-06 | 3.6109064872519575e-06 | 42.89% | 75.09% | 1.75x | ✅ | +| `to_bytes[b'abc']` | 5.983371371601951e-06 | 3.596904579432301e-06 | 39.88% | 66.35% | 1.66x | ✅ | +| `to_bytes[bytearray(0-9)]` | 2.851752689179582e-05 | 1.4100032948586441e-05 | 50.56% | 102.25% | 2.02x | ✅ | +| `to_bytes[bytearray(4-byte pattern)]` | 2.845067834059761e-05 | 1.4245819424813336e-05 | 49.93% | 99.71% | 2.00x | ✅ | +| `to_bytes[bytearray(all byte values)]` | 2.847146062039673e-05 | 1.4114352870484827e-05 | 50.43% | 101.72% | 2.02x | ✅ | +| `to_bytes[bytearray(alternating 0x00/0xff)]` | 2.8244084219536807e-05 | 1.4108083916372851e-05 | 50.05% | 100.20% | 2.00x | ✅ | +| `to_bytes[bytearray(alternating 0xaa/0x55)]` | 2.6805007249030893e-05 | 1.406473615913314e-05 | 47.53% | 90.58% | 1.91x | ✅ | +| `to_bytes[bytearray(ascii sentence)]` | 2.823413988970806e-05 | 1.4000302125732125e-05 | 50.41% | 101.67% | 2.02x | ✅ | +| `to_bytes[bytearray(b'')]` | 2.6639069173684403e-05 | 1.2602941826560676e-05 | 52.69% | 111.37% | 2.11x | ✅ | +| `to_bytes[bytearray(b'\\x00'*32)]` | 2.8156118972531e-05 | 1.3877909544068545e-05 | 50.71% | 102.88% | 2.03x | ✅ | +| `to_bytes[bytearray(b'\\x00\\xff\\x00\\xff')]` | 2.7322220413948243e-05 | 1.3869531555771666e-05 | 49.24% | 96.99% | 1.97x | ✅ | +| `to_bytes[bytearray(b'\\x01'*100)]` | 2.838248918908459e-05 | 1.4130987762821069e-05 | 50.21% | 100.85% | 2.01x | ✅ | +| `to_bytes[bytearray(b'\\x01'*2048)]` | 3.566426924335632e-05 | 1.9741059102779643e-05 | 44.65% | 80.66% | 1.81x | ✅ | +| `to_bytes[bytearray(b'\\x01\\x02\\x03')]` | 2.7769669573774038e-05 | 1.4209190864397038e-05 | 48.83% | 95.43% | 1.95x | ✅ | +| `to_bytes[bytearray(b'\\x10\\x20\\x30\\x40\\x50')]` | 2.821436049417827e-05 | 1.4028346484937784e-05 | 50.28% | 101.12% | 2.01x | ✅ | +| `to_bytes[bytearray(b'\\x7f'*8)]` | 2.8001111534548763e-05 | 1.4112222872031011e-05 | 49.60% | 98.42% | 1.98x | ✅ | +| `to_bytes[bytearray(b'\\x80'*8)]` | 2.8263957611526317e-05 | 1.4051768918369121e-05 | 50.28% | 101.14% | 2.01x | ✅ | +| `to_bytes[bytearray(b'\\xde\\xad\\xbe\\xef')]` | 2.801184594699646e-05 | 1.4217942130193738e-05 | 49.24% | 97.02% | 1.97x | ✅ | +| `to_bytes[bytearray(b'\\xff'*64)]` | 2.814113498014268e-05 | 1.3949142391907784e-05 | 50.43% | 101.74% | 2.02x | ✅ | +| `to_bytes[bytearray(b'a'*1024)]` | 3.450654671454752e-05 | 1.8647268096646113e-05 | 45.96% | 85.05% | 1.85x | ✅ | +| `to_bytes[bytearray(b'abc')]` | 2.826278078576417e-05 | 1.4076240484360553e-05 | 50.20% | 100.78% | 2.01x | ✅ | +| `to_bytes[bytearray(long alternating)]` | 3.428897142317143e-05 | 1.885244665211656e-05 | 45.02% | 81.88% | 1.82x | ✅ | +| `to_bytes[bytearray(mixed pattern)]` | 2.8550843894829426e-05 | 1.4057538033805411e-05 | 50.76% | 103.10% | 2.03x | ✅ | +| `to_bytes[bytearray(multiples of 0x10)]` | 2.841128872876021e-05 | 1.4151446016212423e-05 | 50.19% | 100.77% | 2.01x | ✅ | +| `to_bytes[bytearray(palindrome ascii)]` | 2.8068802539871594e-05 | 1.4087048358979992e-05 | 49.81% | 99.25% | 1.99x | ✅ | +| `to_bytes[bytearray(palindrome numeric)]` | 2.80545669490435e-05 | 1.4007068585212743e-05 | 50.07% | 100.29% | 2.00x | ✅ | +| `to_bytes[bytearray(palindrome)]` | 2.8374768328758902e-05 | 1.4108846841136526e-05 | 50.28% | 101.11% | 2.01x | ✅ | +| `to_bytes[bytearray(repeated 0-9)]` | 2.8606785788866837e-05 | 1.4130353166296833e-05 | 50.60% | 102.45% | 2.02x | ✅ | +| `to_bytes[bytearray(single 0xff)]` | 2.7300373642402008e-05 | 1.3885423983501136e-05 | 49.14% | 96.61% | 1.97x | ✅ | +| `to_bytes[bytearray(single null byte)]` | 2.814976992575725e-05 | 1.386862396273808e-05 | 50.73% | 102.97% | 2.03x | ✅ | +| `to_bytes[bytearray(two patterns)]` | 2.819769312027098e-05 | 1.3986306562031273e-05 | 50.40% | 101.61% | 2.02x | ✅ | +| `to_bytes[long alternating]` | 6.396609815380122e-06 | 3.439330397220323e-06 | 46.23% | 85.98% | 1.86x | ✅ | +| `to_bytes[memoryview(0-9)]` | 4.255114393825894e-05 | 1.686850578079563e-05 | 60.36% | 152.25% | 2.52x | ✅ | +| `to_bytes[memoryview(4-byte pattern)]` | 4.335974687951539e-05 | 1.771775709983696e-05 | 59.14% | 144.72% | 2.45x | ✅ | +| `to_bytes[memoryview(all byte values)]` | 4.2927701557385316e-05 | 1.7745172128233992e-05 | 58.66% | 141.91% | 2.42x | ✅ | +| `to_bytes[memoryview(alternating 0x00/0xff)]` | 4.178031067742147e-05 | 1.6858626134633555e-05 | 59.65% | 147.83% | 2.48x | ✅ | +| `to_bytes[memoryview(alternating 0xaa/0x55)]` | 4.139789092845351e-05 | 1.6836062220090475e-05 | 59.33% | 145.89% | 2.46x | ✅ | +| `to_bytes[memoryview(ascii sentence)]` | 4.129124266139894e-05 | 1.680817534214905e-05 | 59.29% | 145.66% | 2.46x | ✅ | +| `to_bytes[memoryview(b'')]` | 4.1053105093802525e-05 | 1.5148793779229502e-05 | 63.10% | 171.00% | 2.71x | ✅ | +| `to_bytes[memoryview(b'\\x00'*32)]` | 4.110585039715829e-05 | 1.6502010166339198e-05 | 59.85% | 149.10% | 2.49x | ✅ | +| `to_bytes[memoryview(b'\\x00\\xff\\x00\\xff')]` | 4.2435316612999743e-05 | 1.6861035691154262e-05 | 60.27% | 151.68% | 2.52x | ✅ | +| `to_bytes[memoryview(b'\\x01'*100)]` | 4.324380330197488e-05 | 1.745931870406607e-05 | 59.63% | 147.68% | 2.48x | ✅ | +| `to_bytes[memoryview(b'\\x01'*2048)]` | 5.0206085110919153e-05 | 2.471243934399673e-05 | 50.78% | 103.16% | 2.03x | ✅ | +| `to_bytes[memoryview(b'\\x01\\x02\\x03')]` | 4.2447757119633205e-05 | 1.6994701376815252e-05 | 59.96% | 149.77% | 2.50x | ✅ | +| `to_bytes[memoryview(b'\\x10\\x20\\x30\\x40\\x50')]` | 4.1248679638937775e-05 | 1.734914864868936e-05 | 57.94% | 137.76% | 2.38x | ✅ | +| `to_bytes[memoryview(b'\\x7f'*8)]` | 4.174658051909768e-05 | 1.679007976846315e-05 | 59.78% | 148.64% | 2.49x | ✅ | +| `to_bytes[memoryview(b'\\x80'*8)]` | 4.277517067909022e-05 | 1.6897968547959087e-05 | 60.50% | 153.14% | 2.53x | ✅ | +| `to_bytes[memoryview(b'\\xde\\xad\\xbe\\xef')]` | 4.267069336174905e-05 | 1.6777520890177795e-05 | 60.68% | 154.33% | 2.54x | ✅ | +| `to_bytes[memoryview(b'\\xff'*64)]` | 4.111431950229854e-05 | 1.6594332999044477e-05 | 59.64% | 147.76% | 2.48x | ✅ | +| `to_bytes[memoryview(b'a'*1024)]` | 4.970186674479165e-05 | 2.3308744133791374e-05 | 53.10% | 113.23% | 2.13x | ✅ | +| `to_bytes[memoryview(b'abc')]` | 4.2161779398659305e-05 | 1.7233377498499344e-05 | 59.13% | 144.65% | 2.45x | ✅ | +| `to_bytes[memoryview(long alternating)]` | 4.933880648763538e-05 | 2.379929684892584e-05 | 51.76% | 107.31% | 2.07x | ✅ | +| `to_bytes[memoryview(mixed pattern)]` | 4.336767836732776e-05 | 1.7817717463838505e-05 | 58.91% | 143.40% | 2.43x | ✅ | +| `to_bytes[memoryview(multiples of 0x10)]` | 4.2076891338922106e-05 | 1.7082655766101556e-05 | 59.40% | 146.31% | 2.46x | ✅ | +| `to_bytes[memoryview(palindrome ascii)]` | 4.275228517291261e-05 | 1.7060631694258164e-05 | 60.09% | 150.59% | 2.51x | ✅ | +| `to_bytes[memoryview(palindrome numeric)]` | 4.2494318630680566e-05 | 1.74411845198838e-05 | 58.96% | 143.64% | 2.44x | ✅ | +| `to_bytes[memoryview(palindrome)]` | 4.172269363653348e-05 | 1.6836153134686148e-05 | 59.65% | 147.82% | 2.48x | ✅ | +| `to_bytes[memoryview(repeated 0-9)]` | 4.175146999997561e-05 | 1.7582876416691497e-05 | 57.89% | 137.46% | 2.37x | ✅ | +| `to_bytes[memoryview(single 0xff)]` | 4.227267428545802e-05 | 1.733625862334249e-05 | 58.99% | 143.84% | 2.44x | ✅ | +| `to_bytes[memoryview(single null byte)]` | 4.246033378468887e-05 | 1.7390510060750006e-05 | 59.04% | 144.16% | 2.44x | ✅ | +| `to_bytes[memoryview(two patterns)]` | 4.285952619240663e-05 | 1.676726650405356e-05 | 60.88% | 155.61% | 2.56x | ✅ | +| `to_bytes[mixed pattern]` | 6.3728835067023204e-06 | 3.5144979379580874e-06 | 44.85% | 81.33% | 1.81x | ✅ | +| `to_bytes[multiples of 0x10]` | 6.353682758343685e-06 | 3.6064188856255064e-06 | 43.24% | 76.18% | 1.76x | ✅ | +| `to_bytes[palindrome ascii]` | 6.354533869329388e-06 | 3.698503023927502e-06 | 41.80% | 71.81% | 1.72x | ✅ | +| `to_bytes[palindrome numeric]` | 6.398644547904841e-06 | 3.601760442862087e-06 | 43.71% | 77.65% | 1.78x | ✅ | +| `to_bytes[palindrome]` | 6.173316469727805e-06 | 3.6074676640655877e-06 | 41.56% | 71.13% | 1.71x | ✅ | +| `to_bytes[repeated 0-9]` | 6.35993533756668e-06 | 3.5162183911763178e-06 | 44.71% | 80.87% | 1.81x | ✅ | +| `to_bytes[single 0xff]` | 6.343852087509244e-06 | 3.521705533276903e-06 | 44.49% | 80.14% | 1.80x | ✅ | +| `to_bytes[single null byte]` | 6.22791155842468e-06 | 3.5482001633570303e-06 | 43.03% | 75.52% | 1.76x | ✅ | +| `to_bytes[two patterns]` | 6.3927062921028e-06 | 3.592129844784131e-06 | 43.81% | 77.96% | 1.78x | ✅ | diff --git a/benchmarks/results/main.md b/benchmarks/results/main.md new file mode 100644 index 0000000..67f7743 --- /dev/null +++ b/benchmarks/results/main.md @@ -0,0 +1,486 @@ +#### [faster_hexbytes.main](https://github.com/BobTheBuidler/faster-hexbytes/blob/master/faster_hexbytes/main.py) - [view benchmarks](https://github.com/BobTheBuidler/faster-hexbytes/blob/master/benchmarks/test_main_benchmarks.py) + +| Function | Reference Mean | Faster Mean | % Change | Speedup (%) | x Faster | Faster | +|----------|---------------|-------------|----------|-------------|----------|--------| +| `hexbytes_getitem_index[-1-0-9]` | 2.4974771827181897e-05 | 2.3489039626820835e-05 | 5.95% | 6.33% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-4-byte pattern]` | 2.5042264261058584e-05 | 2.364848536772021e-05 | 5.57% | 5.89% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-all byte values]` | 2.5137855625638378e-05 | 2.3720033546297786e-05 | 5.64% | 5.98% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-alternating 0x00/0xff]` | 2.5030684153374865e-05 | 2.3552104820489803e-05 | 5.91% | 6.28% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-alternating 0xaa/0x55]` | 2.505620069627172e-05 | 2.3483708569485328e-05 | 6.28% | 6.70% | 1.07x | ✅ | +| `hexbytes_getitem_index[-1-ascii sentence]` | 2.5064513305574524e-05 | 2.3718124057050798e-05 | 5.37% | 5.68% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x00'*32]` | 2.4985265340223425e-05 | 2.3454761228561156e-05 | 6.13% | 6.53% | 1.07x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x00\\xff\\x00\\xff']` | 2.505699557364792e-05 | 2.3524084615638373e-05 | 6.12% | 6.52% | 1.07x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x01'*100]` | 2.506672216969694e-05 | 2.3596224371056686e-05 | 5.87% | 6.23% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x01'*2048]` | 2.497479688223083e-05 | 2.3483547967537782e-05 | 5.97% | 6.35% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x01\\x02\\x03']` | 2.4442670332048083e-05 | 2.3401986597870747e-05 | 4.26% | 4.45% | 1.04x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x10\\x20\\x30\\x40\\x50']` | 2.5074086215810466e-05 | 2.3598864463180418e-05 | 5.88% | 6.25% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x7f'*8]` | 2.5065014151333793e-05 | 2.3543938923351243e-05 | 6.07% | 6.46% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x80'*8]` | 2.5220519874327197e-05 | 2.37157888911254e-05 | 5.97% | 6.34% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\xde\\xad\\xbe\\xef']` | 2.504567603742626e-05 | 2.3494605446047307e-05 | 6.19% | 6.60% | 1.07x | ✅ | +| `hexbytes_getitem_index[-1-b'\\xff'*64]` | 2.4932125768517834e-05 | 2.3438983457583956e-05 | 5.99% | 6.37% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'a'*1024]` | 2.4882742317005563e-05 | 2.339541785963384e-05 | 5.98% | 6.36% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'abc']` | 2.5031112124800094e-05 | 2.3545826504433072e-05 | 5.93% | 6.31% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-long alternating]` | 2.4832978894317234e-05 | 2.3595585601205813e-05 | 4.98% | 5.24% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-mixed pattern]` | 2.4779676951389124e-05 | 2.3612256333453484e-05 | 4.71% | 4.94% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-multiples of 0x10]` | 2.4824238834000748e-05 | 2.3566153141899418e-05 | 5.07% | 5.34% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-palindrome ascii]` | 2.5154203720767808e-05 | 2.3903923703467056e-05 | 4.97% | 5.23% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-palindrome numeric]` | 2.5181425994367855e-05 | 2.39232222505473e-05 | 5.00% | 5.26% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-palindrome]` | 2.4993928272304583e-05 | 2.3538769680617625e-05 | 5.82% | 6.18% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-repeated 0-9]` | 2.5077524352934472e-05 | 2.35907031759849e-05 | 5.93% | 6.30% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-two patterns]` | 2.4949906681915885e-05 | 2.373517911646081e-05 | 4.87% | 5.12% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-0-9]` | 2.3531756124396414e-05 | 2.2741287052293544e-05 | 3.36% | 3.48% | 1.03x | ✅ | +| `hexbytes_getitem_index[0-4-byte pattern]` | 2.3576078835835645e-05 | 2.2679761240140386e-05 | 3.80% | 3.95% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-all byte values]` | 2.3629023700159172e-05 | 2.2722122217288658e-05 | 3.84% | 3.99% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-alternating 0x00/0xff]` | 2.3975276876259966e-05 | 2.2800886374743004e-05 | 4.90% | 5.15% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-alternating 0xaa/0x55]` | 2.3189177823695155e-05 | 2.2679946931536876e-05 | 2.20% | 2.25% | 1.02x | ✅ | +| `hexbytes_getitem_index[0-ascii sentence]` | 2.3624156649738275e-05 | 2.2553473080793245e-05 | 4.53% | 4.75% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-b'\\x00'*32]` | 2.353438258120873e-05 | 2.2734915814411394e-05 | 3.40% | 3.52% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-b'\\x00\\xff\\x00\\xff']` | 2.374878959330058e-05 | 2.2614185246510433e-05 | 4.78% | 5.02% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-b'\\x01'*100]` | 2.41279313863889e-05 | 2.2596522353938602e-05 | 6.35% | 6.78% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-b'\\x01'*2048]` | 2.3554666650036696e-05 | 2.2645970119406046e-05 | 3.86% | 4.01% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-b'\\x01\\x02\\x03']` | 2.3512114840641765e-05 | 2.271148158157297e-05 | 3.41% | 3.53% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-b'\\x10\\x20\\x30\\x40\\x50']` | 2.377904033408723e-05 | 2.2618658803571557e-05 | 4.88% | 5.13% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-b'\\x7f'*8]` | 2.3571377122273238e-05 | 2.2711353447942822e-05 | 3.65% | 3.79% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-b'\\x80'*8]` | 2.3752596990966765e-05 | 2.2615238351887905e-05 | 4.79% | 5.03% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-b'\\xde\\xad\\xbe\\xef']` | 2.3661120894013888e-05 | 2.2695572302769318e-05 | 4.08% | 4.25% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-b'\\xff'*64]` | 2.3429939678251354e-05 | 2.2578077607577794e-05 | 3.64% | 3.77% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-b'a'*1024]` | 2.3586346502094735e-05 | 2.2583989892457297e-05 | 4.25% | 4.44% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-b'abc']` | 2.3596641890355795e-05 | 2.284988144270888e-05 | 3.16% | 3.27% | 1.03x | ✅ | +| `hexbytes_getitem_index[0-long alternating]` | 2.3579629902354034e-05 | 2.272256452013501e-05 | 3.63% | 3.77% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-mixed pattern]` | 2.348886390218501e-05 | 2.26663205816842e-05 | 3.50% | 3.63% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-multiples of 0x10]` | 2.3755756155565336e-05 | 2.2684444549592303e-05 | 4.51% | 4.72% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-palindrome ascii]` | 2.349535370776188e-05 | 2.2770975763136598e-05 | 3.08% | 3.18% | 1.03x | ✅ | +| `hexbytes_getitem_index[0-palindrome numeric]` | 2.337190945216496e-05 | 2.2694451451694404e-05 | 2.90% | 2.99% | 1.03x | ✅ | +| `hexbytes_getitem_index[0-palindrome]` | 2.3599027229104353e-05 | 2.281287201377941e-05 | 3.33% | 3.45% | 1.03x | ✅ | +| `hexbytes_getitem_index[0-repeated 0-9]` | 2.3479737898393928e-05 | 2.2474100883792333e-05 | 4.28% | 4.47% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-single 0xff]` | 2.3556955424328008e-05 | 2.2498143798931113e-05 | 4.49% | 4.71% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-single null byte]` | 2.3544149302085754e-05 | 2.266364270510691e-05 | 3.74% | 3.89% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-two patterns]` | 2.349938523680419e-05 | 2.267407240939456e-05 | 3.51% | 3.64% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-0-9]` | 2.3941628878856478e-05 | 2.238562197061027e-05 | 6.50% | 6.95% | 1.07x | ✅ | +| `hexbytes_getitem_index[1-4-byte pattern]` | 2.3459215480275835e-05 | 2.25035480580949e-05 | 4.07% | 4.25% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-all byte values]` | 2.3692088205424884e-05 | 2.2429812264125767e-05 | 5.33% | 5.63% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-alternating 0x00/0xff]` | 2.3446280066150825e-05 | 2.24697307576066e-05 | 4.17% | 4.35% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-alternating 0xaa/0x55]` | 2.3563639894989885e-05 | 2.242449026545892e-05 | 4.83% | 5.08% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-ascii sentence]` | 2.356930783917189e-05 | 2.255828929172418e-05 | 4.29% | 4.48% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-b'\\x00'*32]` | 2.346190082259289e-05 | 2.2626844176141594e-05 | 3.56% | 3.69% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-b'\\x00\\xff\\x00\\xff']` | 2.362062629767284e-05 | 2.252990877489162e-05 | 4.62% | 4.84% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-b'\\x01'*100]` | 2.3937010492767375e-05 | 2.258784613295552e-05 | 5.64% | 5.97% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-b'\\x01'*2048]` | 2.3646103622346774e-05 | 2.2537096775883214e-05 | 4.69% | 4.92% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-b'\\x01\\x02\\x03']` | 2.348208895580977e-05 | 2.2687027363485923e-05 | 3.39% | 3.50% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3991542947151564e-05 | 2.3337377714610525e-05 | 2.73% | 2.80% | 1.03x | ✅ | +| `hexbytes_getitem_index[1-b'\\x7f'*8]` | 2.3156590400523595e-05 | 2.2520134405915174e-05 | 2.75% | 2.83% | 1.03x | ✅ | +| `hexbytes_getitem_index[1-b'\\x80'*8]` | 2.4008837328638457e-05 | 2.2551398804038836e-05 | 6.07% | 6.46% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-b'\\xde\\xad\\xbe\\xef']` | 2.357539583778391e-05 | 2.2584879369159534e-05 | 4.20% | 4.39% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-b'\\xff'*64]` | 2.3533563567868987e-05 | 2.2618566487134104e-05 | 3.89% | 4.05% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-b'a'*1024]` | 2.3554919018231658e-05 | 2.255088105796229e-05 | 4.26% | 4.45% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-b'abc']` | 2.3492314519807196e-05 | 2.2429311127976137e-05 | 4.52% | 4.74% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-long alternating]` | 2.3914905642871082e-05 | 2.2409783783821288e-05 | 6.29% | 6.72% | 1.07x | ✅ | +| `hexbytes_getitem_index[1-mixed pattern]` | 2.3402988815528228e-05 | 2.2310055566441695e-05 | 4.67% | 4.90% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-multiples of 0x10]` | 2.3488472063617166e-05 | 2.2483522306279873e-05 | 4.28% | 4.47% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-palindrome ascii]` | 2.3571362515272675e-05 | 2.2638198058688688e-05 | 3.96% | 4.12% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-palindrome numeric]` | 2.3684285678268387e-05 | 2.2492235377861063e-05 | 5.03% | 5.30% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-palindrome]` | 2.366675757241078e-05 | 2.2525830985712013e-05 | 4.82% | 5.06% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-repeated 0-9]` | 2.3805169802398606e-05 | 2.245219139330297e-05 | 5.68% | 6.03% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-two patterns]` | 2.351877033672121e-05 | 2.250451786009603e-05 | 4.31% | 4.51% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-0-9]` | 2.38056461531784e-05 | 2.2675536027782405e-05 | 4.75% | 4.98% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-4-byte pattern]` | 2.402414487694682e-05 | 2.255395929782672e-05 | 6.12% | 6.52% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-all byte values]` | 2.379310589411092e-05 | 2.270728452906697e-05 | 4.56% | 4.78% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-alternating 0x00/0xff]` | 2.3678709834624557e-05 | 2.2926074692318642e-05 | 3.18% | 3.28% | 1.03x | ✅ | +| `hexbytes_getitem_index[2-alternating 0xaa/0x55]` | 2.3850792470361628e-05 | 2.271798365996102e-05 | 4.75% | 4.99% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-ascii sentence]` | 2.343255693489763e-05 | 2.26193151602647e-05 | 3.47% | 3.60% | 1.04x | ✅ | +| `hexbytes_getitem_index[2-b'\\x00'*32]` | 2.352765719876344e-05 | 2.2866431282427788e-05 | 2.81% | 2.89% | 1.03x | ✅ | +| `hexbytes_getitem_index[2-b'\\x00\\xff\\x00\\xff']` | 2.376434511538767e-05 | 2.266823973774627e-05 | 4.61% | 4.84% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-b'\\x01'*100]` | 2.374554875181984e-05 | 2.2639413814062238e-05 | 4.66% | 4.89% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-b'\\x01'*2048]` | 2.3587271081151273e-05 | 2.2660862347001356e-05 | 3.93% | 4.09% | 1.04x | ✅ | +| `hexbytes_getitem_index[2-b'\\x01\\x02\\x03']` | 2.3618608694549723e-05 | 2.252422297816767e-05 | 4.63% | 4.86% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3878174196126332e-05 | 2.254063021125863e-05 | 5.60% | 5.93% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-b'\\x7f'*8]` | 2.3745435800092113e-05 | 2.2745217667866628e-05 | 4.21% | 4.40% | 1.04x | ✅ | +| `hexbytes_getitem_index[2-b'\\x80'*8]` | 2.3788169696168914e-05 | 2.3546484888022876e-05 | 1.02% | 1.03% | 1.01x | ✅ | +| `hexbytes_getitem_index[2-b'\\xde\\xad\\xbe\\xef']` | 2.3646154715422308e-05 | 2.2606969852977713e-05 | 4.39% | 4.60% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-b'\\xff'*64]` | 2.3511709488648884e-05 | 2.257585984883315e-05 | 3.98% | 4.15% | 1.04x | ✅ | +| `hexbytes_getitem_index[2-b'a'*1024]` | 2.3340685865710936e-05 | 2.5423726518153615e-05 | -8.92% | -8.19% | 0.92x | ❌ | +| `hexbytes_getitem_index[2-b'abc']` | 2.3175433063217012e-05 | 2.2550647798866564e-05 | 2.70% | 2.77% | 1.03x | ✅ | +| `hexbytes_getitem_index[2-long alternating]` | 2.406417065333271e-05 | 2.2769548104464662e-05 | 5.38% | 5.69% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-mixed pattern]` | 2.381747839094766e-05 | 2.264675801248471e-05 | 4.92% | 5.17% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-multiples of 0x10]` | 2.3924167514143954e-05 | 2.2585441713199425e-05 | 5.60% | 5.93% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-palindrome ascii]` | 2.4276779224433546e-05 | 2.2666776362671148e-05 | 6.63% | 7.10% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-palindrome numeric]` | 2.373319545585192e-05 | 2.2575056855609498e-05 | 4.88% | 5.13% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-palindrome]` | 2.3723200387610405e-05 | 2.2576568080127513e-05 | 4.83% | 5.08% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-repeated 0-9]` | 2.376872653679594e-05 | 2.2603089299927364e-05 | 4.90% | 5.16% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-two patterns]` | 2.401548532433942e-05 | 2.2681371105368242e-05 | 5.56% | 5.88% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-0-9]` | 2.352170183896843e-05 | 2.264768518871492e-05 | 3.72% | 3.86% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-4-byte pattern]` | 2.3868960758809386e-05 | 2.2630745109388206e-05 | 5.19% | 5.47% | 1.05x | ✅ | +| `hexbytes_getitem_index[3-all byte values]` | 2.3787084368097443e-05 | 2.2591931712582734e-05 | 5.02% | 5.29% | 1.05x | ✅ | +| `hexbytes_getitem_index[3-alternating 0x00/0xff]` | 2.3443288876369168e-05 | 2.2621026493206824e-05 | 3.51% | 3.63% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-alternating 0xaa/0x55]` | 2.3633027335032908e-05 | 2.264748181208867e-05 | 4.17% | 4.35% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-ascii sentence]` | 2.359470180751561e-05 | 2.3024799231359857e-05 | 2.42% | 2.48% | 1.02x | ✅ | +| `hexbytes_getitem_index[3-b'\\x00'*32]` | 2.364100012539441e-05 | 2.269375385658395e-05 | 4.01% | 4.17% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-b'\\x00\\xff\\x00\\xff']` | 2.3738466070879168e-05 | 2.2705073010270786e-05 | 4.35% | 4.55% | 1.05x | ✅ | +| `hexbytes_getitem_index[3-b'\\x01'*100]` | 2.3083935534710256e-05 | 2.2562207394486284e-05 | 2.26% | 2.31% | 1.02x | ✅ | +| `hexbytes_getitem_index[3-b'\\x01'*2048]` | 2.3595955767761793e-05 | 2.265158743013335e-05 | 4.00% | 4.17% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-b'\\x10\\x20\\x30\\x40\\x50']` | 2.356127624915128e-05 | 2.255450410187886e-05 | 4.27% | 4.46% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-b'\\x7f'*8]` | 2.3504053908103263e-05 | 2.256094432605327e-05 | 4.01% | 4.18% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-b'\\x80'*8]` | 2.3632465595161414e-05 | 2.2708662892991892e-05 | 3.91% | 4.07% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-b'\\xde\\xad\\xbe\\xef']` | 2.3563574749203147e-05 | 2.2662682119197078e-05 | 3.82% | 3.98% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-b'\\xff'*64]` | 2.3696092529924618e-05 | 2.2739265207561733e-05 | 4.04% | 4.21% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-b'a'*1024]` | 2.3296208823761148e-05 | 2.2652386143788636e-05 | 2.76% | 2.84% | 1.03x | ✅ | +| `hexbytes_getitem_index[3-long alternating]` | 2.3561565001368354e-05 | 2.2674889307580227e-05 | 3.76% | 3.91% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-mixed pattern]` | 2.3172947933503984e-05 | 2.3099970448697076e-05 | 0.31% | 0.32% | 1.00x | ✅ | +| `hexbytes_getitem_index[3-multiples of 0x10]` | 2.3650420659175694e-05 | 2.2677952409556314e-05 | 4.11% | 4.29% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-palindrome ascii]` | 2.3255683873136807e-05 | 2.26055410408182e-05 | 2.80% | 2.88% | 1.03x | ✅ | +| `hexbytes_getitem_index[3-palindrome numeric]` | 2.35395717155596e-05 | 2.2778075907875456e-05 | 3.23% | 3.34% | 1.03x | ✅ | +| `hexbytes_getitem_index[3-palindrome]` | 2.3591208479724788e-05 | 2.261001301667473e-05 | 4.16% | 4.34% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-repeated 0-9]` | 2.388416667117648e-05 | 2.2984125089478068e-05 | 3.77% | 3.92% | 1.04x | ✅ | +| `hexbytes_getitem_index[3-two patterns]` | 2.3575572267200238e-05 | 2.3043466256344212e-05 | 2.26% | 2.31% | 1.02x | ✅ | +| `hexbytes_getitem_index[4-0-9]` | 2.4525176121878088e-05 | 2.262776935211018e-05 | 7.74% | 8.39% | 1.08x | ✅ | +| `hexbytes_getitem_index[4-4-byte pattern]` | 2.3961711040371482e-05 | 2.2830564497549335e-05 | 4.72% | 4.95% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-all byte values]` | 2.3836781520838963e-05 | 2.262661709153705e-05 | 5.08% | 5.35% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-alternating 0x00/0xff]` | 2.3661589646300122e-05 | 2.2725538629943812e-05 | 3.96% | 4.12% | 1.04x | ✅ | +| `hexbytes_getitem_index[4-alternating 0xaa/0x55]` | 2.3589117664615136e-05 | 2.267387154898413e-05 | 3.88% | 4.04% | 1.04x | ✅ | +| `hexbytes_getitem_index[4-ascii sentence]` | 2.3615789050262544e-05 | 2.2752894466531613e-05 | 3.65% | 3.79% | 1.04x | ✅ | +| `hexbytes_getitem_index[4-b'\\x00'*32]` | 2.4003409113837328e-05 | 2.277283561780547e-05 | 5.13% | 5.40% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-b'\\x01'*100]` | 2.3750211963807595e-05 | 2.2549004762433642e-05 | 5.06% | 5.33% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-b'\\x01'*2048]` | 2.3552691811526164e-05 | 2.264343899004806e-05 | 3.86% | 4.02% | 1.04x | ✅ | +| `hexbytes_getitem_index[4-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3582286682078357e-05 | 2.2649426760779614e-05 | 3.96% | 4.12% | 1.04x | ✅ | +| `hexbytes_getitem_index[4-b'\\x7f'*8]` | 2.404657577595068e-05 | 2.263921945158742e-05 | 5.85% | 6.22% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-b'\\x80'*8]` | 2.3598634252889802e-05 | 2.2548374667400764e-05 | 4.45% | 4.66% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-b'\\xff'*64]` | 2.390939727575443e-05 | 2.290618567958284e-05 | 4.20% | 4.38% | 1.04x | ✅ | +| `hexbytes_getitem_index[4-b'a'*1024]` | 2.4196300895821903e-05 | 2.292420762344336e-05 | 5.26% | 5.55% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-long alternating]` | 2.3583930174205246e-05 | 2.2709808222912416e-05 | 3.71% | 3.85% | 1.04x | ✅ | +| `hexbytes_getitem_index[4-mixed pattern]` | 2.3473257249084387e-05 | 2.2862810801200704e-05 | 2.60% | 2.67% | 1.03x | ✅ | +| `hexbytes_getitem_index[4-multiples of 0x10]` | 2.5700675426862197e-05 | 2.2608641714691918e-05 | 12.03% | 13.68% | 1.14x | ✅ | +| `hexbytes_getitem_index[4-palindrome ascii]` | 2.3819243061133266e-05 | 2.262227306005961e-05 | 5.03% | 5.29% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-palindrome numeric]` | 2.400595745917811e-05 | 2.2693251534891668e-05 | 5.47% | 5.78% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-palindrome]` | 2.3850998087098813e-05 | 2.2687174970925252e-05 | 4.88% | 5.13% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-repeated 0-9]` | 2.3641713373327925e-05 | 2.2624656566259083e-05 | 4.30% | 4.50% | 1.04x | ✅ | +| `hexbytes_getitem_index[4-two patterns]` | 2.4070159762165555e-05 | 2.2801634528547795e-05 | 5.27% | 5.56% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-0-9]` | 2.3494772837147023e-05 | 2.2694280613174702e-05 | 3.41% | 3.53% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-4-byte pattern]` | 2.3539414480592368e-05 | 2.2541399345093492e-05 | 4.24% | 4.43% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-all byte values]` | 2.378670351749675e-05 | 2.2720870991412816e-05 | 4.48% | 4.69% | 1.05x | ✅ | +| `hexbytes_getitem_index[5-alternating 0x00/0xff]` | 2.3702340537911896e-05 | 2.276007528074775e-05 | 3.98% | 4.14% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-alternating 0xaa/0x55]` | 2.381644081747811e-05 | 2.2702645826174637e-05 | 4.68% | 4.91% | 1.05x | ✅ | +| `hexbytes_getitem_index[5-ascii sentence]` | 2.371190746725799e-05 | 2.2871870292634872e-05 | 3.54% | 3.67% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-b'\\x00'*32]` | 2.3718511583509918e-05 | 2.2744703308804984e-05 | 4.11% | 4.28% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-b'\\x01'*100]` | 2.3983787632075288e-05 | 2.2541244996386022e-05 | 6.01% | 6.40% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-b'\\x01'*2048]` | 2.3556159738594564e-05 | 2.2700278746338565e-05 | 3.63% | 3.77% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-b'\\x7f'*8]` | 2.3572105646880208e-05 | 2.257896869417136e-05 | 4.21% | 4.40% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-b'\\x80'*8]` | 2.3542898216567608e-05 | 2.266801256491663e-05 | 3.72% | 3.86% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-b'\\xff'*64]` | 2.3780395081746797e-05 | 2.25313282501527e-05 | 5.25% | 5.54% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-b'a'*1024]` | 2.355476349346277e-05 | 2.254798415098508e-05 | 4.27% | 4.47% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-long alternating]` | 2.374057783340221e-05 | 2.277964168459662e-05 | 4.05% | 4.22% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-mixed pattern]` | 2.351085174205443e-05 | 2.2890762876065602e-05 | 2.64% | 2.71% | 1.03x | ✅ | +| `hexbytes_getitem_index[5-multiples of 0x10]` | 2.3661982297913674e-05 | 2.277617709018382e-05 | 3.74% | 3.89% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-palindrome ascii]` | 2.3598774546248065e-05 | 2.262537666056316e-05 | 4.12% | 4.30% | 1.04x | ✅ | +| `hexbytes_getitem_index[5-palindrome]` | 2.3706213826537514e-05 | 2.2602373839631426e-05 | 4.66% | 4.88% | 1.05x | ✅ | +| `hexbytes_getitem_index[5-repeated 0-9]` | 2.388230786492813e-05 | 2.316317916154929e-05 | 3.01% | 3.10% | 1.03x | ✅ | +| `hexbytes_getitem_index[5-two patterns]` | 2.3905057368030064e-05 | 2.2806155293750798e-05 | 4.60% | 4.82% | 1.05x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-0-9]` | 8.1807222862445e-05 | 5.9997229144795717e-05 | 26.66% | 36.35% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-4-byte pattern]` | 8.24249904829631e-05 | 5.920157512010935e-05 | 28.18% | 39.23% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-all byte values]` | 8.28328714937808e-05 | 5.945431886213159e-05 | 28.22% | 39.32% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-alternating 0x00/0xff]` | 8.171498970646728e-05 | 5.955559021882913e-05 | 27.12% | 37.21% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-alternating 0xaa/0x55]` | 8.198374526523301e-05 | 5.970291985826326e-05 | 27.18% | 37.32% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-ascii sentence]` | 8.240834713923165e-05 | 5.963283501876818e-05 | 27.64% | 38.19% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'']` | 7.969795758647011e-05 | 5.615711002807323e-05 | 29.54% | 41.92% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x00'*32]` | 8.198877241525693e-05 | 5.9707745320091644e-05 | 27.18% | 37.32% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x00\\xff\\x00\\xff']` | 8.17918064407093e-05 | 5.904714668581873e-05 | 27.81% | 38.52% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01'*100]` | 8.209424241953978e-05 | 5.915423204228146e-05 | 27.94% | 38.78% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01'*2048]` | 8.172605460607332e-05 | 6.084237191947639e-05 | 25.55% | 34.32% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01\\x02\\x03']` | 8.228801489595033e-05 | 6.0288748536475645e-05 | 26.73% | 36.49% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.29471064853363e-05 | 5.8802073098994486e-05 | 29.11% | 41.06% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x7f'*8]` | 8.230577548053454e-05 | 5.844981281647389e-05 | 28.98% | 40.81% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x80'*8]` | 8.253931084951528e-05 | 5.861747710174186e-05 | 28.98% | 40.81% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\xde\\xad\\xbe\\xef']` | 8.184164990140425e-05 | 5.957237184411576e-05 | 27.21% | 37.38% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\xff'*64]` | 8.198956765488088e-05 | 5.97879290080012e-05 | 27.08% | 37.13% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'a'*1024]` | 8.226046065150269e-05 | 5.9544669848216484e-05 | 27.61% | 38.15% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'abc']` | 8.213643088566404e-05 | 5.93551538421285e-05 | 27.74% | 38.38% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-long alternating]` | 8.192818568827776e-05 | 5.8958645905785875e-05 | 28.04% | 38.96% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-mixed pattern]` | 8.229289210822741e-05 | 5.96561444752423e-05 | 27.51% | 37.95% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-multiples of 0x10]` | 8.248348989492053e-05 | 5.918728431986466e-05 | 28.24% | 39.36% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-palindrome ascii]` | 8.175582323536863e-05 | 6.00967978423715e-05 | 26.49% | 36.04% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-palindrome numeric]` | 8.307541912677158e-05 | 5.940485330270433e-05 | 28.49% | 39.85% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-palindrome]` | 8.181666001052151e-05 | 5.9506292464221775e-05 | 27.27% | 37.49% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-repeated 0-9]` | 8.201873724236362e-05 | 5.989782829369721e-05 | 26.97% | 36.93% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-single 0xff]` | 8.014176984330732e-05 | 5.676721928237733e-05 | 29.17% | 41.18% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-single null byte]` | 8.023517024714095e-05 | 5.64978863033118e-05 | 29.58% | 42.01% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-two patterns]` | 8.258809353715058e-05 | 5.967140330154876e-05 | 27.75% | 38.40% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-0-9]` | 8.320504102969378e-05 | 6.122787136430511e-05 | 26.41% | 35.89% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-4-byte pattern]` | 8.386511329115284e-05 | 6.123064384370873e-05 | 26.99% | 36.97% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-all byte values]` | 8.302496731844309e-05 | 5.985069594733357e-05 | 27.91% | 38.72% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-alternating 0x00/0xff]` | 8.298318365560194e-05 | 6.121100322060631e-05 | 26.24% | 35.57% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-alternating 0xaa/0x55]` | 8.203895759292778e-05 | 6.141442517776746e-05 | 25.14% | 33.58% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-ascii sentence]` | 8.272887726066396e-05 | 6.050399462428287e-05 | 26.86% | 36.73% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'']` | 8.16214827041035e-05 | 5.6771679112410643e-05 | 30.45% | 43.77% | 1.44x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x00'*32]` | 8.252451973077308e-05 | 5.9740151142291635e-05 | 27.61% | 38.14% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x00\\xff\\x00\\xff']` | 8.283976336311851e-05 | 6.04650075915595e-05 | 27.01% | 37.00% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x01'*100]` | 8.294582069825671e-05 | 6.10532678095884e-05 | 26.39% | 35.86% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x01'*2048]` | 8.270162740920786e-05 | 6.184498455353447e-05 | 25.22% | 33.72% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x01\\x02\\x03']` | 8.272839361042966e-05 | 6.0829623135060095e-05 | 26.47% | 36.00% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.292871643170944e-05 | 6.096480926018756e-05 | 26.49% | 36.03% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x7f'*8]` | 8.286527538676402e-05 | 6.169189214865541e-05 | 25.55% | 34.32% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x80'*8]` | 8.31859128628393e-05 | 6.166477882490589e-05 | 25.87% | 34.90% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\xde\\xad\\xbe\\xef']` | 8.287551448522554e-05 | 5.9906497303248574e-05 | 27.72% | 38.34% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\xff'*64]` | 8.255697961443967e-05 | 6.0019474513974e-05 | 27.30% | 37.55% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'a'*1024]` | 8.245024547542677e-05 | 6.027867157614011e-05 | 26.89% | 36.78% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'abc']` | 8.368583503819143e-05 | 5.961465755596654e-05 | 28.76% | 40.38% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-long alternating]` | 8.295548379642589e-05 | 6.013928916629497e-05 | 27.50% | 37.94% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-mixed pattern]` | 8.367935308764602e-05 | 6.117696927903594e-05 | 26.89% | 36.78% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-multiples of 0x10]` | 8.29518578789461e-05 | 6.114044845752947e-05 | 26.29% | 35.67% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-palindrome ascii]` | 8.31271907762547e-05 | 6.001667424137732e-05 | 27.80% | 38.51% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-palindrome numeric]` | 8.321324121600121e-05 | 6.152099074211855e-05 | 26.07% | 35.26% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-palindrome]` | 8.311192821615457e-05 | 6.100328136925232e-05 | 26.60% | 36.24% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-repeated 0-9]` | 8.329632569915867e-05 | 6.092306652066112e-05 | 26.86% | 36.72% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-single 0xff]` | 8.196026160257089e-05 | 5.915536566246934e-05 | 27.82% | 38.55% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-single null byte]` | 8.22201035343253e-05 | 5.8548341746049254e-05 | 28.79% | 40.43% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-two patterns]` | 8.232190814814828e-05 | 6.145932910340696e-05 | 25.34% | 33.95% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-0-9]` | 8.258868010255385e-05 | 6.088088283508371e-05 | 26.28% | 35.66% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-4-byte pattern]` | 8.277245663970874e-05 | 6.0985625647752965e-05 | 26.32% | 35.72% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-all byte values]` | 8.267570971055513e-05 | 6.02826868754816e-05 | 27.09% | 37.15% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-alternating 0x00/0xff]` | 8.201236396290578e-05 | 6.0641328409378736e-05 | 26.06% | 35.24% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-alternating 0xaa/0x55]` | 8.242143073396986e-05 | 6.096030701591221e-05 | 26.04% | 35.21% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-ascii sentence]` | 8.29842379128199e-05 | 6.088649241862836e-05 | 26.63% | 36.29% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'']` | 8.142580388521194e-05 | 5.8121624367200514e-05 | 28.62% | 40.10% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x00'*32]` | 8.289277337523963e-05 | 6.050633533544789e-05 | 27.01% | 37.00% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x00\\xff\\x00\\xff']` | 8.28780819384874e-05 | 6.123786576120766e-05 | 26.11% | 35.34% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x01'*100]` | 8.342995634794507e-05 | 6.132454888673123e-05 | 26.50% | 36.05% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x01'*2048]` | 8.22942738663925e-05 | 6.074724812180931e-05 | 26.18% | 35.47% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x01\\x02\\x03']` | 8.785850971017545e-05 | 6.0851420685632994e-05 | 30.74% | 44.38% | 1.44x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.237011906797889e-05 | 6.080076536318189e-05 | 26.19% | 35.48% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x7f'*8]` | 8.304288403907543e-05 | 6.087296798736079e-05 | 26.70% | 36.42% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x80'*8]` | 8.201738659781717e-05 | 5.9597350452819365e-05 | 27.34% | 37.62% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\xde\\xad\\xbe\\xef']` | 8.277638928329341e-05 | 6.122039053467858e-05 | 26.04% | 35.21% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\xff'*64]` | 8.316040604999328e-05 | 6.075082356484656e-05 | 26.95% | 36.89% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'a'*1024]` | 8.293158447622718e-05 | 6.104704910009789e-05 | 26.39% | 35.85% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'abc']` | 8.28772422355235e-05 | 6.126042223497819e-05 | 26.08% | 35.29% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-long alternating]` | 8.236114128629583e-05 | 6.070609849246297e-05 | 26.29% | 35.67% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-mixed pattern]` | 8.293711693275335e-05 | 6.063671806789155e-05 | 26.89% | 36.78% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-multiples of 0x10]` | 8.246577336615295e-05 | 6.12691881168452e-05 | 25.70% | 34.60% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-palindrome ascii]` | 8.224864790387141e-05 | 5.996223593900379e-05 | 27.10% | 37.17% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-palindrome numeric]` | 8.224016008737558e-05 | 6.09850875434254e-05 | 25.85% | 34.85% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-palindrome]` | 8.342185923854244e-05 | 6.111968456535099e-05 | 26.73% | 36.49% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-repeated 0-9]` | 8.302850608223495e-05 | 6.059758148631242e-05 | 27.02% | 37.02% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-single 0xff]` | 8.043169036425513e-05 | 5.7865530594262465e-05 | 28.06% | 39.00% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-single null byte]` | 8.015650566616349e-05 | 5.710166765296032e-05 | 28.76% | 40.38% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-two patterns]` | 8.457282133596841e-05 | 5.97616438055746e-05 | 29.34% | 41.52% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-0-9]` | 8.203658328402279e-05 | 5.94270381270672e-05 | 27.56% | 38.05% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-4-byte pattern]` | 8.29050258306599e-05 | 6.144798546843747e-05 | 25.88% | 34.92% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-all byte values]` | 8.400912749853867e-05 | 6.043062421078436e-05 | 28.07% | 39.02% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-alternating 0x00/0xff]` | 8.175442450887898e-05 | 6.064415729453917e-05 | 25.82% | 34.81% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-alternating 0xaa/0x55]` | 8.155910143591384e-05 | 6.021827437330682e-05 | 26.17% | 35.44% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-ascii sentence]` | 8.21928546759113e-05 | 6.023535284823682e-05 | 26.71% | 36.45% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'']` | 7.902845335250642e-05 | 5.6433174885907784e-05 | 28.59% | 40.04% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x00'*32]` | 8.220081831219888e-05 | 5.9618531988966806e-05 | 27.47% | 37.88% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x00\\xff\\x00\\xff']` | 8.204873600488273e-05 | 5.928874043575832e-05 | 27.74% | 38.39% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x01'*100]` | 8.301904613657263e-05 | 6.0707700604737385e-05 | 26.87% | 36.75% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x01'*2048]` | 0.0001028450807974983 | 7.734653058149073e-05 | 24.79% | 32.97% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x01\\x02\\x03']` | 7.913357391067161e-05 | 5.803811356674177e-05 | 26.66% | 36.35% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.113912022820907e-05 | 6.01611375876894e-05 | 25.85% | 34.87% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x7f'*8]` | 8.189697957093498e-05 | 6.016563712301712e-05 | 26.53% | 36.12% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x80'*8]` | 8.223554533126398e-05 | 6.0642442844547924e-05 | 26.26% | 35.61% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\xde\\xad\\xbe\\xef']` | 8.100110586110586e-05 | 6.040496717309101e-05 | 25.43% | 34.10% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\xff'*64]` | 8.276619288987653e-05 | 5.990412975134792e-05 | 27.62% | 38.16% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'a'*1024]` | 9.9628407530254e-05 | 7.427082725696609e-05 | 25.45% | 34.14% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'abc']` | 7.958902295568831e-05 | 5.762582377234449e-05 | 27.60% | 38.11% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-long alternating]` | 9.817604565083925e-05 | 7.205372688084796e-05 | 26.61% | 36.25% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-mixed pattern]` | 8.268140690101945e-05 | 6.048683274366489e-05 | 26.84% | 36.69% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-multiples of 0x10]` | 8.180102919406123e-05 | 6.016158652904973e-05 | 26.45% | 35.97% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-palindrome ascii]` | 8.116429355680348e-05 | 6.020779686382415e-05 | 25.82% | 34.81% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-palindrome numeric]` | 8.240387468311022e-05 | 6.021643443798017e-05 | 26.93% | 36.85% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-palindrome]` | 8.146512842255711e-05 | 6.0604230841119465e-05 | 25.61% | 34.42% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-repeated 0-9]` | 8.196749554932285e-05 | 6.027619760848659e-05 | 26.46% | 35.99% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-single 0xff]` | 7.909181873562078e-05 | 5.732704480460111e-05 | 27.52% | 37.97% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-single null byte]` | 7.888801554615764e-05 | 5.7596226580172724e-05 | 26.99% | 36.97% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-two patterns]` | 8.189265495283023e-05 | 5.9413997318123534e-05 | 27.45% | 37.83% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-0-9]` | 7.9152973530276e-05 | 5.969624430248428e-05 | 24.58% | 32.59% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-4-byte pattern]` | 8.18593062971767e-05 | 5.913166823805286e-05 | 27.76% | 38.44% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-all byte values]` | 8.208000934187286e-05 | 6.035494441709009e-05 | 26.47% | 36.00% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-alternating 0x00/0xff]` | 8.123016792000633e-05 | 5.8129192176410106e-05 | 28.44% | 39.74% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-alternating 0xaa/0x55]` | 8.021587733150122e-05 | 5.905375380211634e-05 | 26.38% | 35.84% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-ascii sentence]` | 8.11784417472778e-05 | 5.8444388936553094e-05 | 28.01% | 38.90% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'']` | 7.728551451728731e-05 | 5.531194321309669e-05 | 28.43% | 39.73% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x00'*32]` | 8.088997614324134e-05 | 5.956166112943284e-05 | 26.37% | 35.81% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x00\\xff\\x00\\xff']` | 8.118982444830399e-05 | 5.85445823673635e-05 | 27.89% | 38.68% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x01'*100]` | 8.134790412224398e-05 | 5.889806324885278e-05 | 27.60% | 38.12% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x01'*2048]` | 0.00010385878998054752 | 7.925633258559273e-05 | 23.69% | 31.04% | 1.31x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x01\\x02\\x03']` | 8.144931092152343e-05 | 5.896924712696603e-05 | 27.60% | 38.12% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.128890928782362e-05 | 5.894104014551262e-05 | 27.49% | 37.92% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x7f'*8]` | 8.124802631170336e-05 | 5.848885807476847e-05 | 28.01% | 38.91% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x80'*8]` | 8.094466198643525e-05 | 5.8836590801745915e-05 | 27.31% | 37.58% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\xde\\xad\\xbe\\xef']` | 8.153681271141924e-05 | 5.9113138530114735e-05 | 27.50% | 37.93% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\xff'*64]` | 8.409464076440318e-05 | 5.858039621103465e-05 | 30.34% | 43.55% | 1.44x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'a'*1024]` | 9.760208603052784e-05 | 6.966693940122302e-05 | 28.62% | 40.10% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'abc']` | 8.067368753605621e-05 | 5.85494093620054e-05 | 27.42% | 37.79% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-long alternating]` | 9.775082075122012e-05 | 7.343030965253507e-05 | 24.88% | 33.12% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-mixed pattern]` | 8.31031816136865e-05 | 5.990878133386008e-05 | 27.91% | 38.72% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-multiples of 0x10]` | 8.059508797707632e-05 | 5.888164899676408e-05 | 26.94% | 36.88% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-palindrome ascii]` | 8.007276574210268e-05 | 5.8767365721377277e-05 | 26.61% | 36.25% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-palindrome numeric]` | 7.996746130188414e-05 | 5.9475462797985856e-05 | 25.63% | 34.45% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-palindrome]` | 8.118084941671731e-05 | 5.829913009371328e-05 | 28.19% | 39.25% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-repeated 0-9]` | 8.177320476749755e-05 | 6.0115834146295225e-05 | 26.48% | 36.03% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-single 0xff]` | 7.84264983426921e-05 | 5.55718018044726e-05 | 29.14% | 41.13% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-single null byte]` | 7.871906521638573e-05 | 5.5951169572966895e-05 | 28.92% | 40.69% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-two patterns]` | 8.149280297410073e-05 | 5.946231747297086e-05 | 27.03% | 37.05% | 1.37x | ✅ | +| `hexbytes_new['']` | 7.148950182357841e-05 | 3.650197789704897e-05 | 48.94% | 95.85% | 1.96x | ✅ | +| `hexbytes_new['0x'+'00'*64]` | 9.358483769926962e-05 | 4.9843395498548066e-05 | 46.74% | 87.76% | 1.88x | ✅ | +| `hexbytes_new['0x'+'a'*128]` | 9.189749487968337e-05 | 4.982670872027036e-05 | 45.78% | 84.43% | 1.84x | ✅ | +| `hexbytes_new['0x'+'ff'*32]` | 8.832906475928902e-05 | 4.69525406732175e-05 | 46.84% | 88.12% | 1.88x | ✅ | +| `hexbytes_new['0x']` | 7.676769172137512e-05 | 3.816998188823712e-05 | 50.28% | 101.12% | 2.01x | ✅ | +| `hexbytes_new['0x1234']` | 8.471796234250887e-05 | 4.6204161032186073e-05 | 45.46% | 83.36% | 1.83x | ✅ | +| `hexbytes_new['0xCAFEBABE']` | 8.533961416626809e-05 | 4.477525304033944e-05 | 47.53% | 90.60% | 1.91x | ✅ | +| `hexbytes_new['0xabcdef']` | 8.503679950467101e-05 | 4.4752842991948403e-05 | 47.37% | 90.01% | 1.90x | ✅ | +| `hexbytes_new['0xdeadbeef']` | 8.534749706339073e-05 | 4.576765110275924e-05 | 46.37% | 86.48% | 1.86x | ✅ | +| `hexbytes_new['abc']` | 8.129709627774969e-05 | 4.7994103541239996e-05 | 40.96% | 69.39% | 1.69x | ✅ | +| `hexbytes_new['deadbeef']` | 7.638385932762877e-05 | 4.158883177031625e-05 | 45.55% | 83.66% | 1.84x | ✅ | +| `hexbytes_new[0-9]` | 4.289016112920993e-05 | 2.5647795783027006e-05 | 40.20% | 67.23% | 1.67x | ✅ | +| `hexbytes_new[0]` | 0.00012093895886853503 | 6.021180310364426e-05 | 50.21% | 100.86% | 2.01x | ✅ | +| `hexbytes_new[123456]` | 0.0001260200250815464 | 6.451711012853436e-05 | 48.80% | 95.33% | 1.95x | ✅ | +| `hexbytes_new[2**16]` | 0.00012559709199321813 | 6.500539311057827e-05 | 48.24% | 93.21% | 1.93x | ✅ | +| `hexbytes_new[2**256-1]` | 0.00013068302840459599 | 7.284482793926838e-05 | 44.26% | 79.40% | 1.79x | ✅ | +| `hexbytes_new[2**32]` | 0.0001281273320013475 | 6.943948900720488e-05 | 45.80% | 84.52% | 1.85x | ✅ | +| `hexbytes_new[2**64]` | 0.00013194520188788576 | 7.067452403086369e-05 | 46.44% | 86.69% | 1.87x | ✅ | +| `hexbytes_new[2**8]` | 0.00012561912582057463 | 6.274947537486014e-05 | 50.05% | 100.19% | 2.00x | ✅ | +| `hexbytes_new[4-byte pattern]` | 4.462450768751657e-05 | 2.6735683562009473e-05 | 40.09% | 66.91% | 1.67x | ✅ | +| `hexbytes_new[False]` | 6.0366210805303116e-05 | 2.7043188394343984e-05 | 55.20% | 123.22% | 2.23x | ✅ | +| `hexbytes_new[True]` | 6.017522541325868e-05 | 2.703932500996497e-05 | 55.07% | 122.55% | 2.23x | ✅ | +| `hexbytes_new[all byte values]` | 4.47246921253948e-05 | 2.6815909234065835e-05 | 40.04% | 66.78% | 1.67x | ✅ | +| `hexbytes_new[alternating 0x00/0xff]` | 4.355576031028297e-05 | 2.6621259983211745e-05 | 38.88% | 63.61% | 1.64x | ✅ | +| `hexbytes_new[alternating 0xaa/0x55]` | 4.3841356212329594e-05 | 2.6572458576985276e-05 | 39.39% | 64.99% | 1.65x | ✅ | +| `hexbytes_new[ascii sentence]` | 4.391945895007535e-05 | 2.594023706585904e-05 | 40.94% | 69.31% | 1.69x | ✅ | +| `hexbytes_new[b'']` | 4.327434264631157e-05 | 2.5416582317799044e-05 | 41.27% | 70.26% | 1.70x | ✅ | +| `hexbytes_new[b'\\x00'*32]` | 4.423827706476327e-05 | 2.576889708019414e-05 | 41.75% | 71.67% | 1.72x | ✅ | +| `hexbytes_new[b'\\x00\\xff\\x00\\xff']` | 4.320832087223283e-05 | 2.5880276633467055e-05 | 40.10% | 66.95% | 1.67x | ✅ | +| `hexbytes_new[b'\\x01'*100]` | 4.397156910626475e-05 | 2.642647733478491e-05 | 39.90% | 66.39% | 1.66x | ✅ | +| `hexbytes_new[b'\\x01'*2048]` | 5.607355055341031e-05 | 3.764157976420107e-05 | 32.87% | 48.97% | 1.49x | ✅ | +| `hexbytes_new[b'\\x01\\x02\\x03']` | 4.3018929819123396e-05 | 2.5934238600257064e-05 | 39.71% | 65.88% | 1.66x | ✅ | +| `hexbytes_new[b'\\x10\\x20\\x30\\x40\\x50']` | 4.3334456259308725e-05 | 2.5746975035217327e-05 | 40.59% | 68.31% | 1.68x | ✅ | +| `hexbytes_new[b'\\x7f'*8]` | 4.2641561860162495e-05 | 2.589991806898433e-05 | 39.26% | 64.64% | 1.65x | ✅ | +| `hexbytes_new[b'\\x80'*8]` | 4.269074874028573e-05 | 2.577659927523718e-05 | 39.62% | 65.62% | 1.66x | ✅ | +| `hexbytes_new[b'\\xde\\xad\\xbe\\xef']` | 4.318912308061793e-05 | 2.582846617434561e-05 | 40.20% | 67.22% | 1.67x | ✅ | +| `hexbytes_new[b'\\xff'*64]` | 4.417367688035411e-05 | 2.6447417936434043e-05 | 40.13% | 67.02% | 1.67x | ✅ | +| `hexbytes_new[b'a'*1024]` | 5.0931310580290575e-05 | 3.307112372235356e-05 | 35.07% | 54.01% | 1.54x | ✅ | +| `hexbytes_new[b'abc']` | 4.236298152764865e-05 | 2.5832415460961843e-05 | 39.02% | 63.99% | 1.64x | ✅ | +| `hexbytes_new[bytearray(0-9)]` | 7.045871208886052e-05 | 3.683549899608564e-05 | 47.72% | 91.28% | 1.91x | ✅ | +| `hexbytes_new[bytearray(4-byte pattern)]` | 7.166523729739957e-05 | 3.844677763998921e-05 | 46.35% | 86.40% | 1.86x | ✅ | +| `hexbytes_new[bytearray(all byte values)]` | 7.098564592167361e-05 | 3.8472049136010257e-05 | 45.80% | 84.51% | 1.85x | ✅ | +| `hexbytes_new[bytearray(alternating 0x00/0xff)]` | 6.940366444420513e-05 | 3.800467300395006e-05 | 45.24% | 82.62% | 1.83x | ✅ | +| `hexbytes_new[bytearray(alternating 0xaa/0x55)]` | 6.966829897446534e-05 | 3.763963624726345e-05 | 45.97% | 85.09% | 1.85x | ✅ | +| `hexbytes_new[bytearray(ascii sentence)]` | 6.97869359827139e-05 | 3.71550873489367e-05 | 46.76% | 87.83% | 1.88x | ✅ | +| `hexbytes_new[bytearray(b'')]` | 6.780604549383803e-05 | 3.6499190990747486e-05 | 46.17% | 85.77% | 1.86x | ✅ | +| `hexbytes_new[bytearray(b'\\x00'*32)]` | 6.992749850064798e-05 | 3.757131369904655e-05 | 46.27% | 86.12% | 1.86x | ✅ | +| `hexbytes_new[bytearray(b'\\x00\\xff\\x00\\xff')]` | 6.887641771388022e-05 | 3.7090221988645774e-05 | 46.15% | 85.70% | 1.86x | ✅ | +| `hexbytes_new[bytearray(b'\\x01'*100)]` | 6.927264757993604e-05 | 3.795827736361415e-05 | 45.20% | 82.50% | 1.82x | ✅ | +| `hexbytes_new[bytearray(b'\\x01'*2048)]` | 9.114776847639032e-05 | 5.60072029435165e-05 | 38.55% | 62.74% | 1.63x | ✅ | +| `hexbytes_new[bytearray(b'\\x01\\x02\\x03')]` | 6.922256197638075e-05 | 3.80530813998411e-05 | 45.03% | 81.91% | 1.82x | ✅ | +| `hexbytes_new[bytearray(b'\\x10\\x20\\x30\\x40\\x50')]` | 6.994507118533474e-05 | 3.756646216840679e-05 | 46.29% | 86.19% | 1.86x | ✅ | +| `hexbytes_new[bytearray(b'\\x7f'*8)]` | 6.94542553162907e-05 | 3.688475619873286e-05 | 46.89% | 88.30% | 1.88x | ✅ | +| `hexbytes_new[bytearray(b'\\x80'*8)]` | 6.797863074947109e-05 | 3.879106146026928e-05 | 42.94% | 75.24% | 1.75x | ✅ | +| `hexbytes_new[bytearray(b'\\xde\\xad\\xbe\\xef')]` | 6.961445822131029e-05 | 3.769910501750878e-05 | 45.85% | 84.66% | 1.85x | ✅ | +| `hexbytes_new[bytearray(b'\\xff'*64)]` | 7.029988383586764e-05 | 3.775147892337086e-05 | 46.30% | 86.22% | 1.86x | ✅ | +| `hexbytes_new[bytearray(b'a'*1024)]` | 8.387260367202745e-05 | 5.0149086135850755e-05 | 40.21% | 67.25% | 1.67x | ✅ | +| `hexbytes_new[bytearray(b'abc')]` | 6.850292111778162e-05 | 3.798622341342398e-05 | 44.55% | 80.34% | 1.80x | ✅ | +| `hexbytes_new[bytearray(long alternating)]` | 8.488076324864742e-05 | 4.8865551231413156e-05 | 42.43% | 73.70% | 1.74x | ✅ | +| `hexbytes_new[bytearray(mixed pattern)]` | 6.978112002237504e-05 | 3.840300524136304e-05 | 44.97% | 81.71% | 1.82x | ✅ | +| `hexbytes_new[bytearray(multiples of 0x10)]` | 6.896242173837826e-05 | 3.707783368484466e-05 | 46.23% | 85.99% | 1.86x | ✅ | +| `hexbytes_new[bytearray(palindrome ascii)]` | 6.986721939549855e-05 | 3.770852082548275e-05 | 46.03% | 85.28% | 1.85x | ✅ | +| `hexbytes_new[bytearray(palindrome numeric)]` | 6.997370716813158e-05 | 3.7849418040369834e-05 | 45.91% | 84.87% | 1.85x | ✅ | +| `hexbytes_new[bytearray(palindrome)]` | 6.914011142535209e-05 | 3.773540019011639e-05 | 45.42% | 83.22% | 1.83x | ✅ | +| `hexbytes_new[bytearray(repeated 0-9)]` | 7.00657073383709e-05 | 3.831093936271626e-05 | 45.32% | 82.89% | 1.83x | ✅ | +| `hexbytes_new[bytearray(single 0xff)]` | 6.98841381596689e-05 | 3.7566400220737145e-05 | 46.24% | 86.03% | 1.86x | ✅ | +| `hexbytes_new[bytearray(single null byte)]` | 6.924880578799991e-05 | 3.767532550309247e-05 | 45.59% | 83.80% | 1.84x | ✅ | +| `hexbytes_new[bytearray(two patterns)]` | 6.947620547303888e-05 | 3.748011770995262e-05 | 46.05% | 85.37% | 1.85x | ✅ | +| `hexbytes_new[long alternating]` | 5.1097519242649246e-05 | 3.345319756360052e-05 | 34.53% | 52.74% | 1.53x | ✅ | +| `hexbytes_new[memoryview(0-9)]` | 8.343221614032439e-05 | 4.36590986728306e-05 | 47.67% | 91.10% | 1.91x | ✅ | +| `hexbytes_new[memoryview(4-byte pattern)]` | 8.285066041253311e-05 | 4.40799115675712e-05 | 46.80% | 87.96% | 1.88x | ✅ | +| `hexbytes_new[memoryview(all byte values)]` | 8.494278891791339e-05 | 4.459505322662305e-05 | 47.50% | 90.48% | 1.90x | ✅ | +| `hexbytes_new[memoryview(alternating 0x00/0xff)]` | 8.388395003962605e-05 | 4.308938878629255e-05 | 48.63% | 94.67% | 1.95x | ✅ | +| `hexbytes_new[memoryview(alternating 0xaa/0x55)]` | 8.391858533827448e-05 | 4.3179926800531924e-05 | 48.55% | 94.35% | 1.94x | ✅ | +| `hexbytes_new[memoryview(ascii sentence)]` | 8.408382146868732e-05 | 4.3468303488406014e-05 | 48.30% | 93.44% | 1.93x | ✅ | +| `hexbytes_new[memoryview(b'')]` | 8.180991201097388e-05 | 3.9934110126305814e-05 | 51.19% | 104.86% | 2.05x | ✅ | +| `hexbytes_new[memoryview(b'\\x00'*32)]` | 8.375462141026185e-05 | 4.312408647695375e-05 | 48.51% | 94.22% | 1.94x | ✅ | +| `hexbytes_new[memoryview(b'\\x00\\xff\\x00\\xff')]` | 8.339169067440344e-05 | 4.309045834321292e-05 | 48.33% | 93.53% | 1.94x | ✅ | +| `hexbytes_new[memoryview(b'\\x01'*100)]` | 8.548323533155023e-05 | 4.375384037030436e-05 | 48.82% | 95.37% | 1.95x | ✅ | +| `hexbytes_new[memoryview(b'\\x01'*2048)]` | 0.00010344784394316022 | 6.33326107820724e-05 | 38.78% | 63.34% | 1.63x | ✅ | +| `hexbytes_new[memoryview(b'\\x01\\x02\\x03')]` | 8.392134048613179e-05 | 4.320388950882725e-05 | 48.52% | 94.24% | 1.94x | ✅ | +| `hexbytes_new[memoryview(b'\\x10\\x20\\x30\\x40\\x50')]` | 8.309189839714384e-05 | 4.302419475116532e-05 | 48.22% | 93.13% | 1.93x | ✅ | +| `hexbytes_new[memoryview(b'\\x7f'*8)]` | 8.377004131940622e-05 | 4.352522102160985e-05 | 48.04% | 92.46% | 1.92x | ✅ | +| `hexbytes_new[memoryview(b'\\x80'*8)]` | 8.29842111926247e-05 | 4.3681221504718204e-05 | 47.36% | 89.98% | 1.90x | ✅ | +| `hexbytes_new[memoryview(b'\\xde\\xad\\xbe\\xef')]` | 8.333172503946815e-05 | 4.330861835366188e-05 | 48.03% | 92.41% | 1.92x | ✅ | +| `hexbytes_new[memoryview(b'\\xff'*64)]` | 8.378417060732439e-05 | 4.320168562001813e-05 | 48.44% | 93.94% | 1.94x | ✅ | +| `hexbytes_new[memoryview(b'a'*1024)]` | 9.857278428497213e-05 | 5.705425636983039e-05 | 42.12% | 72.77% | 1.73x | ✅ | +| `hexbytes_new[memoryview(b'abc')]` | 8.4425066104159e-05 | 4.304196606015389e-05 | 49.02% | 96.15% | 1.96x | ✅ | +| `hexbytes_new[memoryview(long alternating)]` | 9.924816176267955e-05 | 5.740402688889272e-05 | 42.16% | 72.89% | 1.73x | ✅ | +| `hexbytes_new[memoryview(mixed pattern)]` | 8.435678032132668e-05 | 4.363051067851422e-05 | 48.28% | 93.34% | 1.93x | ✅ | +| `hexbytes_new[memoryview(multiples of 0x10)]` | 8.354137184065266e-05 | 4.3768414041803676e-05 | 47.61% | 90.87% | 1.91x | ✅ | +| `hexbytes_new[memoryview(palindrome ascii)]` | 8.331868203055655e-05 | 4.3396009563477474e-05 | 47.92% | 92.00% | 1.92x | ✅ | +| `hexbytes_new[memoryview(palindrome numeric)]` | 8.397547948203961e-05 | 4.3399830026839546e-05 | 48.32% | 93.49% | 1.93x | ✅ | +| `hexbytes_new[memoryview(palindrome)]` | 8.338533538497878e-05 | 4.349954036952347e-05 | 47.83% | 91.69% | 1.92x | ✅ | +| `hexbytes_new[memoryview(repeated 0-9)]` | 8.582737730877845e-05 | 4.413480106695719e-05 | 48.58% | 94.47% | 1.94x | ✅ | +| `hexbytes_new[memoryview(single 0xff)]` | 8.46231529023384e-05 | 4.30952027793332e-05 | 49.07% | 96.36% | 1.96x | ✅ | +| `hexbytes_new[memoryview(single null byte)]` | 8.405009030576114e-05 | 4.271293534766858e-05 | 49.18% | 96.78% | 1.97x | ✅ | +| `hexbytes_new[memoryview(two patterns)]` | 8.50920724648015e-05 | 4.33449178554612e-05 | 49.06% | 96.31% | 1.96x | ✅ | +| `hexbytes_new[mixed pattern]` | 4.427149513057917e-05 | 2.6609164969296743e-05 | 39.90% | 66.38% | 1.66x | ✅ | +| `hexbytes_new[multiples of 0x10]` | 4.258011632578378e-05 | 2.575039001995724e-05 | 39.52% | 65.36% | 1.65x | ✅ | +| `hexbytes_new[palindrome ascii]` | 4.3544252595990946e-05 | 2.5833839605496694e-05 | 40.67% | 68.56% | 1.69x | ✅ | +| `hexbytes_new[palindrome numeric]` | 4.337033624368194e-05 | 2.5953687172624074e-05 | 40.16% | 67.11% | 1.67x | ✅ | +| `hexbytes_new[palindrome]` | 4.274955952415865e-05 | 2.597662513603741e-05 | 39.24% | 64.57% | 1.65x | ✅ | +| `hexbytes_new[repeated 0-9]` | 4.4081580309151495e-05 | 2.655182822062712e-05 | 39.77% | 66.02% | 1.66x | ✅ | +| `hexbytes_new[single 0xff]` | 4.292112810721459e-05 | 2.5521212015400887e-05 | 40.54% | 68.18% | 1.68x | ✅ | +| `hexbytes_new[single null byte]` | 4.304494697523589e-05 | 2.5548954915146624e-05 | 40.65% | 68.48% | 1.68x | ✅ | +| `hexbytes_new[two patterns]` | 4.404407819320639e-05 | 2.669610311409445e-05 | 39.39% | 64.98% | 1.65x | ✅ | +| `hexbytes_repr[0-9]` | 2.9588213073828735e-05 | 1.4621829176395931e-05 | 50.58% | 102.36% | 2.02x | ✅ | +| `hexbytes_repr[4-byte pattern]` | 0.00012441522074825744 | 4.224375210193357e-05 | 66.05% | 194.52% | 2.95x | ✅ | +| `hexbytes_repr[all byte values]` | 0.0001243877588668308 | 4.2269285901795665e-05 | 66.02% | 194.27% | 2.94x | ✅ | +| `hexbytes_repr[alternating 0x00/0xff]` | 5.046478020246737e-05 | 2.0218238392069667e-05 | 59.94% | 149.60% | 2.50x | ✅ | +| `hexbytes_repr[alternating 0xaa/0x55]` | 4.982250514120161e-05 | 2.0528921799957834e-05 | 58.80% | 142.69% | 2.43x | ✅ | +| `hexbytes_repr[ascii sentence]` | 4.237967126024896e-05 | 1.8434924593134785e-05 | 56.50% | 129.89% | 2.30x | ✅ | +| `hexbytes_repr[b'']` | 2.1208347571021193e-05 | 1.2373379567997006e-05 | 41.66% | 71.40% | 1.71x | ✅ | +| `hexbytes_repr[b'\\x00'*32]` | 3.788374564663557e-05 | 1.713585504482458e-05 | 54.77% | 121.08% | 2.21x | ✅ | +| `hexbytes_repr[b'\\x00\\xff\\x00\\xff']` | 2.674949471141985e-05 | 1.4370969620486268e-05 | 46.28% | 86.14% | 1.86x | ✅ | +| `hexbytes_repr[b'\\x01'*100]` | 6.315730528153836e-05 | 2.42373472897257e-05 | 61.62% | 160.58% | 2.61x | ✅ | +| `hexbytes_repr[b'\\x01'*2048]` | 0.0008080169775453316 | 0.00023417376367213734 | 71.02% | 245.05% | 3.45x | ✅ | +| `hexbytes_repr[b'\\x01\\x02\\x03']` | 2.6317448427096368e-05 | 1.4291215619239822e-05 | 45.70% | 84.15% | 1.84x | ✅ | +| `hexbytes_repr[b'\\x10\\x20\\x30\\x40\\x50']` | 2.693674298351449e-05 | 1.4406292120774373e-05 | 46.52% | 86.98% | 1.87x | ✅ | +| `hexbytes_repr[b'\\x7f'*8]` | 2.8624203074748704e-05 | 1.4631226932397154e-05 | 48.89% | 95.64% | 1.96x | ✅ | +| `hexbytes_repr[b'\\x80'*8]` | 2.8676307806495364e-05 | 1.48070931068369e-05 | 48.36% | 93.67% | 1.94x | ✅ | +| `hexbytes_repr[b'\\xde\\xad\\xbe\\xef']` | 2.6334001851291295e-05 | 1.4088291076531398e-05 | 46.50% | 86.92% | 1.87x | ✅ | +| `hexbytes_repr[b'\\xff'*64]` | 4.9770784726355503e-05 | 2.0375554762540072e-05 | 59.06% | 144.27% | 2.44x | ✅ | +| `hexbytes_repr[b'a'*1024]` | 0.0004136946862825496 | 0.00012416564439337707 | 69.99% | 233.18% | 3.33x | ✅ | +| `hexbytes_repr[b'abc']` | 2.6364721121036088e-05 | 1.425297676011533e-05 | 45.94% | 84.98% | 1.85x | ✅ | +| `hexbytes_repr[long alternating]` | 0.0004166126955786844 | 0.00012752279417729153 | 69.39% | 226.70% | 3.27x | ✅ | +| `hexbytes_repr[mixed pattern]` | 0.00010138845912183875 | 3.524970446800069e-05 | 65.23% | 187.63% | 2.88x | ✅ | +| `hexbytes_repr[multiples of 0x10]` | 2.9494506836380725e-05 | 1.4631887184669185e-05 | 50.39% | 101.58% | 2.02x | ✅ | +| `hexbytes_repr[palindrome ascii]` | 2.8103322063570174e-05 | 1.4966526976495922e-05 | 46.74% | 87.77% | 1.88x | ✅ | +| `hexbytes_repr[palindrome numeric]` | 2.7575787507902326e-05 | 1.4317995433361243e-05 | 48.08% | 92.60% | 1.93x | ✅ | +| `hexbytes_repr[palindrome]` | 3.272060438767215e-05 | 1.6129531525962358e-05 | 50.71% | 102.86% | 2.03x | ✅ | +| `hexbytes_repr[repeated 0-9]` | 6.317388374999597e-05 | 2.4181129004704727e-05 | 61.72% | 161.25% | 2.61x | ✅ | +| `hexbytes_repr[single 0xff]` | 2.5584168555655887e-05 | 1.3934733512339212e-05 | 45.53% | 83.60% | 1.84x | ✅ | +| `hexbytes_repr[single null byte]` | 2.5684957868679025e-05 | 1.3949773932988784e-05 | 45.69% | 84.12% | 1.84x | ✅ | +| `hexbytes_repr[two patterns]` | 5.005306074935921e-05 | 2.0451997935656888e-05 | 59.14% | 144.73% | 2.45x | ✅ | +| `hexbytes_to_0x_hex[0-9]` | 1.5705236758283588e-05 | 1.3835869946633897e-05 | 11.90% | 13.51% | 1.14x | ✅ | +| `hexbytes_to_0x_hex[4-byte pattern]` | 4.35579543105141e-05 | 4.132141538453929e-05 | 5.13% | 5.41% | 1.05x | ✅ | +| `hexbytes_to_0x_hex[all byte values]` | 4.404208225939965e-05 | 4.1796901778162476e-05 | 5.10% | 5.37% | 1.05x | ✅ | +| `hexbytes_to_0x_hex[alternating 0x00/0xff]` | 2.1502443715701346e-05 | 1.9477211856640206e-05 | 9.42% | 10.40% | 1.10x | ✅ | +| `hexbytes_to_0x_hex[alternating 0xaa/0x55]` | 2.1530605585571888e-05 | 1.9547649361770845e-05 | 9.21% | 10.14% | 1.10x | ✅ | +| `hexbytes_to_0x_hex[ascii sentence]` | 1.9264486584258556e-05 | 1.7263578253831497e-05 | 10.39% | 11.59% | 1.12x | ✅ | +| `hexbytes_to_0x_hex[b'']` | 1.0230918058479275e-05 | 1.1346902966026289e-05 | -10.91% | -9.84% | 0.90x | ❌ | +| `hexbytes_to_0x_hex[b'\\x00'*32]` | 1.7801088634380032e-05 | 1.5988275521520448e-05 | 10.18% | 11.34% | 1.11x | ✅ | +| `hexbytes_to_0x_hex[b'\\x00\\xff\\x00\\xff']` | 1.518226723461978e-05 | 1.3166136811019283e-05 | 13.28% | 15.31% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[b'\\x01'*100]` | 2.563121232039722e-05 | 2.3079302424109427e-05 | 9.96% | 11.06% | 1.11x | ✅ | +| `hexbytes_to_0x_hex[b'\\x01'*2048]` | 0.00023484271357191062 | 0.00023245887506656796 | 1.02% | 1.03% | 1.01x | ✅ | +| `hexbytes_to_0x_hex[b'\\x01\\x02\\x03']` | 1.5107766213292168e-05 | 1.315784681041234e-05 | 12.91% | 14.82% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[b'\\x10\\x20\\x30\\x40\\x50']` | 1.5147212104347612e-05 | 1.3464869884485243e-05 | 11.11% | 12.49% | 1.12x | ✅ | +| `hexbytes_to_0x_hex[b'\\x7f'*8]` | 1.558481904298038e-05 | 1.3565944789756698e-05 | 12.95% | 14.88% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[b'\\x80'*8]` | 1.5391846057002166e-05 | 1.3501301501411687e-05 | 12.28% | 14.00% | 1.14x | ✅ | +| `hexbytes_to_0x_hex[b'\\xde\\xad\\xbe\\xef']` | 1.5287012054854068e-05 | 1.3163008839618544e-05 | 13.89% | 16.14% | 1.16x | ✅ | +| `hexbytes_to_0x_hex[b'\\xff'*64]` | 2.1141548365353688e-05 | 1.94566014247515e-05 | 7.97% | 8.66% | 1.09x | ✅ | +| `hexbytes_to_0x_hex[b'a'*1024]` | 0.00012903325307777995 | 0.00012736624515628572 | 1.29% | 1.31% | 1.01x | ✅ | +| `hexbytes_to_0x_hex[b'abc']` | 1.5176872489380172e-05 | 1.3271781285505391e-05 | 12.55% | 14.35% | 1.14x | ✅ | +| `hexbytes_to_0x_hex[long alternating]` | 0.0001284360897470229 | 0.00012820298429832853 | 0.18% | 0.18% | 1.00x | ✅ | +| `hexbytes_to_0x_hex[mixed pattern]` | 3.642851616623274e-05 | 3.436185192765364e-05 | 5.67% | 6.01% | 1.06x | ✅ | +| `hexbytes_to_0x_hex[multiples of 0x10]` | 1.5638629244101037e-05 | 1.387158431141875e-05 | 11.30% | 12.74% | 1.13x | ✅ | +| `hexbytes_to_0x_hex[palindrome ascii]` | 1.541045241681804e-05 | 1.3116639476423924e-05 | 14.88% | 17.49% | 1.17x | ✅ | +| `hexbytes_to_0x_hex[palindrome numeric]` | 1.533920013117867e-05 | 1.3230525886412996e-05 | 13.75% | 15.94% | 1.16x | ✅ | +| `hexbytes_to_0x_hex[palindrome]` | 1.6705621772344522e-05 | 1.5011957268613367e-05 | 10.14% | 11.28% | 1.11x | ✅ | +| `hexbytes_to_0x_hex[repeated 0-9]` | 2.5662089874202047e-05 | 2.297810263507965e-05 | 10.46% | 11.68% | 1.12x | ✅ | +| `hexbytes_to_0x_hex[single 0xff]` | 1.4982400863608847e-05 | 1.3055497209485186e-05 | 12.86% | 14.76% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[single null byte]` | 1.4995807527761192e-05 | 1.292973782655825e-05 | 13.78% | 15.98% | 1.16x | ✅ | +| `hexbytes_to_0x_hex[two patterns]` | 2.1151482246689096e-05 | 1.9339856526958228e-05 | 8.57% | 9.37% | 1.09x | ✅ | diff --git a/benchmarks/test__utils_benchmarks.py b/benchmarks/test__utils_benchmarks.py new file mode 100644 index 0000000..5049c14 --- /dev/null +++ b/benchmarks/test__utils_benchmarks.py @@ -0,0 +1,43 @@ +from typing import Any, Callable + +import hexbytes._utils +import pytest +from eth_typing import HexStr +from pytest_codspeed import BenchmarkFixture + +import faster_hexbytes._utils +from benchmarks.params import ( + TO_BYTES_VALS, + TO_BYTES_IDS, + HEXSTRINGS, + HEXSTRINGS_IDS, +) + + +def run_100(func: Callable[..., Any], *args: Any) -> None: + for i in range(100): + func(*args) + + +@pytest.mark.benchmark(group="to_bytes") +@pytest.mark.parametrize("val", TO_BYTES_VALS, ids=TO_BYTES_IDS) +def test_to_bytes(benchmark: BenchmarkFixture, val: Any) -> None: + benchmark(run_100, hexbytes._utils.to_bytes, val) + + +@pytest.mark.benchmark(group="to_bytes") +@pytest.mark.parametrize("val", TO_BYTES_VALS, ids=TO_BYTES_IDS) +def test_faster_to_bytes(benchmark: BenchmarkFixture, val: Any) -> None: + benchmark(run_100, faster_hexbytes._utils.to_bytes, val) + + +@pytest.mark.benchmark(group="hexstr_to_bytes") +@pytest.mark.parametrize("hexstr", HEXSTRINGS, ids=HEXSTRINGS_IDS) +def test_hexstr_to_bytes(benchmark: BenchmarkFixture, hexstr: HexStr) -> None: + benchmark(run_100, hexbytes._utils.hexstr_to_bytes, hexstr) + + +@pytest.mark.benchmark(group="hexstr_to_bytes") +@pytest.mark.parametrize("hexstr", HEXSTRINGS, ids=HEXSTRINGS_IDS) +def test_faster_hexstr_to_bytes(benchmark: BenchmarkFixture, hexstr: HexStr) -> None: + benchmark(run_100, faster_hexbytes._utils.hexstr_to_bytes, hexstr) diff --git a/benchmarks/test_main_benchmarks.py b/benchmarks/test_main_benchmarks.py new file mode 100644 index 0000000..0ed29c8 --- /dev/null +++ b/benchmarks/test_main_benchmarks.py @@ -0,0 +1,102 @@ +from typing import Any, Callable + +import hexbytes +import pytest +from pytest_codspeed import BenchmarkFixture + +import faster_hexbytes +from benchmarks.params import ( + CONSTRUCTOR_VALS, + CONSTRUCTOR_IDS, + BYTES_VALS, + BYTES_IDS, + SLICES, + SLICE_IDS, +) + + +def run_100(func: Callable[..., Any], *args: Any) -> None: + for i in range(100): + func(*args) + + +@pytest.mark.benchmark(group="HexBytes.__new__") +@pytest.mark.parametrize("val", CONSTRUCTOR_VALS, ids=CONSTRUCTOR_IDS) +def test_hexbytes_new(benchmark: BenchmarkFixture, val: Any) -> None: + benchmark(run_100, hexbytes.HexBytes, val) + + +@pytest.mark.benchmark(group="HexBytes.__new__") +@pytest.mark.parametrize("val", CONSTRUCTOR_VALS, ids=CONSTRUCTOR_IDS) +def test_faster_hexbytes_new(benchmark: BenchmarkFixture, val: Any) -> None: + benchmark(run_100, faster_hexbytes.HexBytes, val) + + +@pytest.mark.benchmark(group="HexBytes.__getitem__ (index)") +@pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) +@pytest.mark.parametrize("idx", [0, 1, 2, 3, 4, 5, -1]) +def test_hexbytes_getitem_index( + benchmark: BenchmarkFixture, val: bytes, idx: int +) -> None: + obj = hexbytes.HexBytes(val) + if len(val) > abs(idx): + benchmark(run_100, lambda: obj[idx]) + + +@pytest.mark.benchmark(group="HexBytes.__getitem__ (index)") +@pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) +@pytest.mark.parametrize("idx", [0, 1, 2, 3, 4, 5, -1]) +def test_faster_hexbytes_getitem_index( + benchmark: BenchmarkFixture, val: bytes, idx: int +) -> None: + obj = faster_hexbytes.HexBytes(val) + if len(val) > abs(idx): + benchmark(run_100, lambda: obj[idx]) + + +@pytest.mark.benchmark(group="HexBytes.__getitem__ (slice)") +@pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) +@pytest.mark.parametrize("slice_", SLICES, ids=SLICE_IDS) +def test_hexbytes_getitem_slice( + benchmark: BenchmarkFixture, val: bytes, slice_: slice +) -> None: + obj = hexbytes.HexBytes(val) + benchmark(run_100, lambda: obj[slice_]) + + +@pytest.mark.benchmark(group="HexBytes.__getitem__ (slice)") +@pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) +@pytest.mark.parametrize("slice_", SLICES, ids=SLICE_IDS) +def test_faster_hexbytes_getitem_slice( + benchmark: BenchmarkFixture, val: bytes, slice_: slice +) -> None: + obj = faster_hexbytes.HexBytes(val) + benchmark(run_100, lambda: obj[slice_]) + + +@pytest.mark.benchmark(group="HexBytes.__repr__") +@pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) +def test_hexbytes_repr(benchmark: BenchmarkFixture, val: bytes) -> None: + obj = hexbytes.HexBytes(val) + benchmark(run_100, obj.__repr__) + + +@pytest.mark.benchmark(group="HexBytes.__repr__") +@pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) +def test_faster_hexbytes_repr(benchmark: BenchmarkFixture, val: bytes) -> None: + obj = faster_hexbytes.HexBytes(val) + benchmark(run_100, obj.__repr__) + + +@pytest.mark.benchmark(group="HexBytes.to_0x_hex") +@pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) +def test_hexbytes_to_0x_hex(benchmark: BenchmarkFixture, val: bytes) -> None: + obj = hexbytes.HexBytes(val) + benchmark(run_100, obj.to_0x_hex) + + +@pytest.mark.benchmark(group="HexBytes.to_0x_hex") +@pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) +def test_faster_hexbytes_to_0x_hex(benchmark: BenchmarkFixture, val: bytes) -> None: + obj = faster_hexbytes.HexBytes(val) + benchmark(run_100, obj.to_0x_hex) diff --git a/build/__native_6a32f4913d613d6a7ddf.c b/build/__native_6a32f4913d613d6a7ddf.c new file mode 100644 index 0000000..c73096d --- /dev/null +++ b/build/__native_6a32f4913d613d6a7ddf.c @@ -0,0 +1,3611 @@ +#ifndef DIFFCHECK_PLACEHOLDER +#define DIFFCHECK_PLACEHOLDER 0 +#endif +#include "init.c" +#include "getargs.c" +#include "getargsfast.c" +#include "int_ops.c" +#include "float_ops.c" +#include "str_ops.c" +#include "bytes_ops.c" +#include "list_ops.c" +#include "dict_ops.c" +#include "set_ops.c" +#include "tuple_ops.c" +#include "exc_ops.c" +#include "misc_ops.c" +#include "generic_ops.c" +#include "pythonsupport.c" +#include "__native_6a32f4913d613d6a7ddf.h" +#include "__native_internal_6a32f4913d613d6a7ddf.h" +static PyMethodDef faster_hexbytesmodule_methods[] = { + {NULL, NULL, 0, NULL} +}; + +int CPyExec_faster_hexbytes(PyObject *module) +{ + PyObject* modname = NULL; + modname = PyObject_GetAttrString((PyObject *)CPyModule_faster_hexbytes__internal, "__name__"); + CPyStatic_faster_hexbytes___globals = PyModule_GetDict(CPyModule_faster_hexbytes__internal); + if (unlikely(CPyStatic_faster_hexbytes___globals == NULL)) + goto fail; + if (CPyGlobalsInit() < 0) + goto fail; + char result = CPyDef_faster_hexbytes_____top_level__(); + if (result == 2) + goto fail; + Py_DECREF(modname); + return 0; + fail: + Py_CLEAR(CPyModule_faster_hexbytes__internal); + Py_CLEAR(modname); + return -1; +} +static struct PyModuleDef faster_hexbytesmodule = { + PyModuleDef_HEAD_INIT, + "faster_hexbytes", + NULL, /* docstring */ + 0, /* size of per-interpreter state of the module */ + faster_hexbytesmodule_methods, + NULL, +}; + +PyObject *CPyInit_faster_hexbytes(void) +{ + if (CPyModule_faster_hexbytes__internal) { + Py_INCREF(CPyModule_faster_hexbytes__internal); + return CPyModule_faster_hexbytes__internal; + } + CPyModule_faster_hexbytes__internal = PyModule_Create(&faster_hexbytesmodule); + if (unlikely(CPyModule_faster_hexbytes__internal == NULL)) + goto fail; + if (CPyExec_faster_hexbytes(CPyModule_faster_hexbytes__internal) != 0) + goto fail; + return CPyModule_faster_hexbytes__internal; + fail: + return NULL; +} + +char CPyDef_faster_hexbytes_____top_level__(void) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + char cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + PyObject *cpy_r_r5; + PyObject *cpy_r_r6; + PyObject *cpy_r_r7; + PyObject *cpy_r_r8; + PyObject *cpy_r_r9; + PyObject *cpy_r_r10; + PyObject *cpy_r_r11; + PyObject *cpy_r_r12; + PyObject *cpy_r_r13; + PyObject *cpy_r_r14; + PyObject *cpy_r_r15; + CPyPtr cpy_r_r16; + CPyPtr cpy_r_r17; + PyObject *cpy_r_r18; + PyObject *cpy_r_r19; + int32_t cpy_r_r20; + char cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + PyObject *cpy_r_r24; + PyObject *cpy_r_r25; + PyObject **cpy_r_r27; + PyObject *cpy_r_r28; + PyObject *cpy_r_r29; + PyObject *cpy_r_r30; + PyObject *cpy_r_r31; + int32_t cpy_r_r32; + char cpy_r_r33; + char cpy_r_r34; + cpy_r_r0 = CPyModule_builtins; + cpy_r_r1 = (PyObject *)&_Py_NoneStruct; + cpy_r_r2 = cpy_r_r0 != cpy_r_r1; + if (cpy_r_r2) goto CPyL3; + cpy_r_r3 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'builtins' */ + cpy_r_r4 = PyImport_Import(cpy_r_r3); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", -1, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + CPyModule_builtins = cpy_r_r4; + CPy_INCREF(CPyModule_builtins); + CPy_DECREF(cpy_r_r4); +CPyL3: ; + cpy_r_r5 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('version',) */ + cpy_r_r6 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('__version',) */ + cpy_r_r7 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'importlib.metadata' */ + cpy_r_r8 = CPyStatic_faster_hexbytes___globals; + cpy_r_r9 = CPyImport_ImportFromMany(cpy_r_r7, cpy_r_r5, cpy_r_r6, cpy_r_r8); + if (unlikely(cpy_r_r9 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + CPyModule_importlib___metadata = cpy_r_r9; + CPy_INCREF(CPyModule_importlib___metadata); + CPy_DECREF(cpy_r_r9); + cpy_r_r10 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('HexBytes',) */ + cpy_r_r11 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes.main' */ + cpy_r_r12 = CPyStatic_faster_hexbytes___globals; + cpy_r_r13 = CPyImport_ImportFromMany(cpy_r_r11, cpy_r_r10, cpy_r_r10, cpy_r_r12); + if (unlikely(cpy_r_r13 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + CPyModule_faster_hexbytes___main = cpy_r_r13; + CPy_INCREF(CPyModule_faster_hexbytes___main); + CPy_DECREF(cpy_r_r13); + cpy_r_r14 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'HexBytes' */ + cpy_r_r15 = PyList_New(1); + if (unlikely(cpy_r_r15 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + cpy_r_r16 = (CPyPtr)&((PyListObject *)cpy_r_r15)->ob_item; + cpy_r_r17 = *(CPyPtr *)cpy_r_r16; + CPy_INCREF(cpy_r_r14); + *(PyObject * *)cpy_r_r17 = cpy_r_r14; + cpy_r_r18 = CPyStatic_faster_hexbytes___globals; + cpy_r_r19 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__all__' */ + cpy_r_r20 = CPyDict_SetItem(cpy_r_r18, cpy_r_r19, cpy_r_r15); + CPy_DECREF_NO_IMM(cpy_r_r15); + cpy_r_r21 = cpy_r_r20 >= 0; + if (unlikely(!cpy_r_r21)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + cpy_r_r22 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'hexbytes' */ + cpy_r_r23 = CPyStatic_faster_hexbytes___globals; + cpy_r_r24 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__version' */ + cpy_r_r25 = CPyDict_GetItem(cpy_r_r23, cpy_r_r24); + if (unlikely(cpy_r_r25 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + PyObject *cpy_r_r26[1] = {cpy_r_r22}; + cpy_r_r27 = (PyObject **)&cpy_r_r26; + cpy_r_r28 = PyObject_Vectorcall(cpy_r_r25, cpy_r_r27, 1, 0); + CPy_DECREF(cpy_r_r25); + if (unlikely(cpy_r_r28 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + if (likely(PyUnicode_Check(cpy_r_r28))) + cpy_r_r29 = cpy_r_r28; + else { + CPy_TypeErrorTraceback("faster_hexbytes/__init__.py", "", 11, CPyStatic_faster_hexbytes___globals, "str", cpy_r_r28); + goto CPyL12; + } + cpy_r_r30 = CPyStatic_faster_hexbytes___globals; + cpy_r_r31 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__version__' */ + cpy_r_r32 = CPyDict_SetItem(cpy_r_r30, cpy_r_r31, cpy_r_r29); + CPy_DECREF(cpy_r_r29); + cpy_r_r33 = cpy_r_r32 >= 0; + if (unlikely(!cpy_r_r33)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + return 1; +CPyL12: ; + cpy_r_r34 = 2; + return cpy_r_r34; +} +static PyMethodDef _utilsmodule_methods[] = { + {"to_bytes", (PyCFunction)CPyPy__utils___to_bytes, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("to_bytes(val)\n--\n\n") /* docstring */}, + {"hexstr_to_bytes", (PyCFunction)CPyPy__utils___hexstr_to_bytes, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("hexstr_to_bytes(hexstr)\n--\n\n") /* docstring */}, + {NULL, NULL, 0, NULL} +}; + +int CPyExec_faster_hexbytes____utils(PyObject *module) +{ + PyObject* modname = NULL; + modname = PyObject_GetAttrString((PyObject *)CPyModule_faster_hexbytes____utils__internal, "__name__"); + CPyStatic__utils___globals = PyModule_GetDict(CPyModule_faster_hexbytes____utils__internal); + if (unlikely(CPyStatic__utils___globals == NULL)) + goto fail; + if (CPyGlobalsInit() < 0) + goto fail; + char result = CPyDef__utils_____top_level__(); + if (result == 2) + goto fail; + Py_DECREF(modname); + return 0; + fail: + Py_CLEAR(CPyModule_faster_hexbytes____utils__internal); + Py_CLEAR(modname); + CPy_XDECREF(CPyStatic__utils___unhexlify); + CPyStatic__utils___unhexlify = NULL; + return -1; +} +static struct PyModuleDef _utilsmodule = { + PyModuleDef_HEAD_INIT, + "faster_hexbytes._utils", + NULL, /* docstring */ + 0, /* size of per-interpreter state of the module */ + _utilsmodule_methods, + NULL, +}; + +PyObject *CPyInit_faster_hexbytes____utils(void) +{ + if (CPyModule_faster_hexbytes____utils__internal) { + Py_INCREF(CPyModule_faster_hexbytes____utils__internal); + return CPyModule_faster_hexbytes____utils__internal; + } + CPyModule_faster_hexbytes____utils__internal = PyModule_Create(&_utilsmodule); + if (unlikely(CPyModule_faster_hexbytes____utils__internal == NULL)) + goto fail; + if (CPyExec_faster_hexbytes____utils(CPyModule_faster_hexbytes____utils__internal) != 0) + goto fail; + return CPyModule_faster_hexbytes____utils__internal; + fail: + return NULL; +} + +PyObject *CPyDef__utils___to_bytes(PyObject *cpy_r_val) { + char cpy_r_r0; + PyObject *cpy_r_r1; + char cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + char cpy_r_r5; + PyObject *cpy_r_r6; + PyObject **cpy_r_r8; + PyObject *cpy_r_r9; + PyObject *cpy_r_r10; + char cpy_r_r11; + char cpy_r_r12; + PyObject *cpy_r_r13; + PyObject *cpy_r_r14; + PyObject *cpy_r_r15; + char cpy_r_r16; + CPyTagged cpy_r_r17; + int64_t cpy_r_r18; + char cpy_r_r19; + int64_t cpy_r_r20; + char cpy_r_r21; + char cpy_r_r22; + char cpy_r_r23; + char cpy_r_r24; + PyObject *cpy_r_r25; + CPyTagged cpy_r_r26; + PyObject *cpy_r_r27; + PyObject *cpy_r_r28; + PyObject *cpy_r_r29; + PyObject *cpy_r_r30; + PyObject *cpy_r_r31; + PyObject *cpy_r_r32; + PyObject **cpy_r_r34; + PyObject *cpy_r_r35; + CPyTagged cpy_r_r36; + PyObject *cpy_r_r37; + PyObject *cpy_r_r38; + PyObject *cpy_r_r39; + PyObject *cpy_r_r40; + PyObject **cpy_r_r42; + PyObject *cpy_r_r43; + PyObject *cpy_r_r44; + PyObject *cpy_r_r45; + PyObject *cpy_r_r46; + PyObject *cpy_r_r47; + PyObject *cpy_r_r48; + int32_t cpy_r_r49; + char cpy_r_r50; + char cpy_r_r51; + PyObject *cpy_r_r52; + PyObject **cpy_r_r54; + PyObject *cpy_r_r55; + PyObject *cpy_r_r56; + PyObject *cpy_r_r57; + PyObject *cpy_r_r58; + PyObject *cpy_r_r59; + PyObject *cpy_r_r60; + PyObject *cpy_r_r61; + PyObject **cpy_r_r63; + PyObject *cpy_r_r64; + PyObject *cpy_r_r65; + PyObject *cpy_r_r66; + PyObject *cpy_r_r67; + PyObject *cpy_r_r68; + PyObject *cpy_r_r69; + PyObject **cpy_r_r71; + PyObject *cpy_r_r72; + PyObject *cpy_r_r73; + PyObject *cpy_r_r74; + CPyPtr cpy_r_r75; + CPyPtr cpy_r_r76; + CPyPtr cpy_r_r77; + CPyPtr cpy_r_r78; + CPyPtr cpy_r_r79; + CPyPtr cpy_r_r80; + PyObject *cpy_r_r81; + PyObject *cpy_r_r82; + PyObject *cpy_r_r83; + PyObject *cpy_r_r84; + PyObject **cpy_r_r86; + PyObject *cpy_r_r87; + PyObject *cpy_r_r88; + cpy_r_r0 = PyBytes_Check(cpy_r_val); + if (!cpy_r_r0) goto CPyL3; + CPy_INCREF(cpy_r_val); + if (likely(PyBytes_Check(cpy_r_val) || PyByteArray_Check(cpy_r_val))) + cpy_r_r1 = cpy_r_val; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "to_bytes", 19, CPyStatic__utils___globals, "bytes", cpy_r_val); + goto CPyL51; + } + return cpy_r_r1; +CPyL3: ; + cpy_r_r2 = PyUnicode_Check(cpy_r_val); + if (!cpy_r_r2) goto CPyL7; + CPy_INCREF(cpy_r_val); + if (likely(PyUnicode_Check(cpy_r_val))) + cpy_r_r3 = cpy_r_val; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "to_bytes", 21, CPyStatic__utils___globals, "str", cpy_r_val); + goto CPyL51; + } + cpy_r_r4 = CPyDef__utils___hexstr_to_bytes(cpy_r_r3); + CPy_DECREF(cpy_r_r3); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + return cpy_r_r4; +CPyL7: ; + cpy_r_r5 = PyByteArray_Check(cpy_r_val); + if (!cpy_r_r5) goto CPyL11; + cpy_r_r6 = (PyObject *)&PyBytes_Type; + PyObject *cpy_r_r7[1] = {cpy_r_val}; + cpy_r_r8 = (PyObject **)&cpy_r_r7; + cpy_r_r9 = PyObject_Vectorcall(cpy_r_r6, cpy_r_r8, 1, 0); + if (unlikely(cpy_r_r9 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + if (likely(PyBytes_Check(cpy_r_r9) || PyByteArray_Check(cpy_r_r9))) + cpy_r_r10 = cpy_r_r9; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "to_bytes", 23, CPyStatic__utils___globals, "bytes", cpy_r_r9); + goto CPyL51; + } + return cpy_r_r10; +CPyL11: ; + cpy_r_r11 = PyBool_Check(cpy_r_val); + if (!cpy_r_r11) goto CPyL17; + if (unlikely(!PyBool_Check(cpy_r_val))) { + CPy_TypeError("bool", cpy_r_val); cpy_r_r12 = 2; + } else + cpy_r_r12 = cpy_r_val == Py_True; + if (unlikely(cpy_r_r12 == 2)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + if (!cpy_r_r12) goto CPyL15; + cpy_r_r13 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* b'\x01' */ + CPy_INCREF(cpy_r_r13); + cpy_r_r14 = cpy_r_r13; + goto CPyL16; +CPyL15: ; + cpy_r_r15 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* b'\x00' */ + CPy_INCREF(cpy_r_r15); + cpy_r_r14 = cpy_r_r15; +CPyL16: ; + return cpy_r_r14; +CPyL17: ; + cpy_r_r16 = PyLong_Check(cpy_r_val); + if (!cpy_r_r16) goto CPyL37; + if (likely(PyLong_Check(cpy_r_val))) + cpy_r_r17 = CPyTagged_FromObject(cpy_r_val); + else { + CPy_TypeError("int", cpy_r_val); cpy_r_r17 = CPY_INT_TAG; + } + if (unlikely(cpy_r_r17 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r18 = cpy_r_r17 & 1; + cpy_r_r19 = cpy_r_r18 != 0; + if (cpy_r_r19) goto CPyL21; + cpy_r_r20 = 0 & 1; + cpy_r_r21 = cpy_r_r20 != 0; + if (!cpy_r_r21) goto CPyL22; +CPyL21: ; + cpy_r_r22 = CPyTagged_IsLt_(cpy_r_r17, 0); + cpy_r_r23 = cpy_r_r22; + goto CPyL23; +CPyL22: ; + cpy_r_r24 = (Py_ssize_t)cpy_r_r17 < (Py_ssize_t)0; + cpy_r_r23 = cpy_r_r24; +CPyL23: ; + CPyTagged_DECREF(cpy_r_r17); + if (!cpy_r_r23) goto CPyL31; + cpy_r_r25 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'Cannot convert negative integer ' */ + if (likely(PyLong_Check(cpy_r_val))) + cpy_r_r26 = CPyTagged_FromObject(cpy_r_val); + else { + CPy_TypeError("int", cpy_r_val); cpy_r_r26 = CPY_INT_TAG; + } + if (unlikely(cpy_r_r26 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r27 = CPyTagged_Str(cpy_r_r26); + CPyTagged_DECREF(cpy_r_r26); + if (unlikely(cpy_r_r27 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r28 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ' to bytes' */ + cpy_r_r29 = CPyStr_Build(3, cpy_r_r25, cpy_r_r27, cpy_r_r28); + CPy_DECREF(cpy_r_r27); + if (unlikely(cpy_r_r29 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r30 = CPyModule_builtins; + cpy_r_r31 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'ValueError' */ + cpy_r_r32 = CPyObject_GetAttr(cpy_r_r30, cpy_r_r31); + if (unlikely(cpy_r_r32 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL52; + } + PyObject *cpy_r_r33[1] = {cpy_r_r29}; + cpy_r_r34 = (PyObject **)&cpy_r_r33; + cpy_r_r35 = PyObject_Vectorcall(cpy_r_r32, cpy_r_r34, 1, 0); + CPy_DECREF(cpy_r_r32); + if (unlikely(cpy_r_r35 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL52; + } + CPy_DECREF(cpy_r_r29); + CPy_Raise(cpy_r_r35); + CPy_DECREF(cpy_r_r35); + if (unlikely(!0)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + CPy_Unreachable(); +CPyL31: ; + if (likely(PyLong_Check(cpy_r_val))) + cpy_r_r36 = CPyTagged_FromObject(cpy_r_val); + else { + CPy_TypeError("int", cpy_r_val); cpy_r_r36 = CPY_INT_TAG; + } + if (unlikely(cpy_r_r36 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r37 = CPyModule_builtins; + cpy_r_r38 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'hex' */ + cpy_r_r39 = CPyObject_GetAttr(cpy_r_r37, cpy_r_r38); + if (unlikely(cpy_r_r39 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL53; + } + cpy_r_r40 = CPyTagged_StealAsObject(cpy_r_r36); + PyObject *cpy_r_r41[1] = {cpy_r_r40}; + cpy_r_r42 = (PyObject **)&cpy_r_r41; + cpy_r_r43 = PyObject_Vectorcall(cpy_r_r39, cpy_r_r42, 1, 0); + CPy_DECREF(cpy_r_r39); + if (unlikely(cpy_r_r43 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL54; + } + CPy_DECREF(cpy_r_r40); + if (likely(PyUnicode_Check(cpy_r_r43))) + cpy_r_r44 = cpy_r_r43; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "to_bytes", 32, CPyStatic__utils___globals, "str", cpy_r_r43); + goto CPyL51; + } + cpy_r_r45 = CPyDef__utils___to_bytes(cpy_r_r44); + CPy_DECREF(cpy_r_r44); + if (unlikely(cpy_r_r45 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + return cpy_r_r45; +CPyL37: ; + cpy_r_r46 = CPyModule_builtins; + cpy_r_r47 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'memoryview' */ + cpy_r_r48 = CPyObject_GetAttr(cpy_r_r46, cpy_r_r47); + if (unlikely(cpy_r_r48 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r49 = PyObject_IsInstance(cpy_r_val, cpy_r_r48); + CPy_DECREF(cpy_r_r48); + cpy_r_r50 = cpy_r_r49 >= 0; + if (unlikely(!cpy_r_r50)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r51 = cpy_r_r49; + if (!cpy_r_r51) goto CPyL43; + cpy_r_r52 = (PyObject *)&PyBytes_Type; + PyObject *cpy_r_r53[1] = {cpy_r_val}; + cpy_r_r54 = (PyObject **)&cpy_r_r53; + cpy_r_r55 = PyObject_Vectorcall(cpy_r_r52, cpy_r_r54, 1, 0); + if (unlikely(cpy_r_r55 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + if (likely(PyBytes_Check(cpy_r_r55) || PyByteArray_Check(cpy_r_r55))) + cpy_r_r56 = cpy_r_r55; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "to_bytes", 34, CPyStatic__utils___globals, "bytes", cpy_r_r55); + goto CPyL51; + } + return cpy_r_r56; +CPyL43: ; + cpy_r_r57 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ + cpy_r_r58 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'Cannot convert ' */ + cpy_r_r59 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '{!r:{}}' */ + cpy_r_r60 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ + cpy_r_r61 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'format' */ + PyObject *cpy_r_r62[3] = {cpy_r_r59, cpy_r_val, cpy_r_r60}; + cpy_r_r63 = (PyObject **)&cpy_r_r62; + cpy_r_r64 = PyObject_VectorcallMethod(cpy_r_r61, cpy_r_r63, 9223372036854775811ULL, 0); + if (unlikely(cpy_r_r64 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r65 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ' of type ' */ + cpy_r_r66 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '{:{}}' */ + cpy_r_r67 = CPy_TYPE(cpy_r_val); + cpy_r_r68 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ + cpy_r_r69 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'format' */ + PyObject *cpy_r_r70[3] = {cpy_r_r66, cpy_r_r67, cpy_r_r68}; + cpy_r_r71 = (PyObject **)&cpy_r_r70; + cpy_r_r72 = PyObject_VectorcallMethod(cpy_r_r69, cpy_r_r71, 9223372036854775811ULL, 0); + if (unlikely(cpy_r_r72 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL55; + } + CPy_DECREF(cpy_r_r67); + cpy_r_r73 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ' to bytes' */ + cpy_r_r74 = PyList_New(5); + if (unlikely(cpy_r_r74 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL56; + } + cpy_r_r75 = (CPyPtr)&((PyListObject *)cpy_r_r74)->ob_item; + cpy_r_r76 = *(CPyPtr *)cpy_r_r75; + CPy_INCREF(cpy_r_r58); + *(PyObject * *)cpy_r_r76 = cpy_r_r58; + cpy_r_r77 = cpy_r_r76 + 8; + *(PyObject * *)cpy_r_r77 = cpy_r_r64; + CPy_INCREF(cpy_r_r65); + cpy_r_r78 = cpy_r_r76 + 16; + *(PyObject * *)cpy_r_r78 = cpy_r_r65; + cpy_r_r79 = cpy_r_r76 + 24; + *(PyObject * *)cpy_r_r79 = cpy_r_r72; + CPy_INCREF(cpy_r_r73); + cpy_r_r80 = cpy_r_r76 + 32; + *(PyObject * *)cpy_r_r80 = cpy_r_r73; + cpy_r_r81 = PyUnicode_Join(cpy_r_r57, cpy_r_r74); + CPy_DECREF_NO_IMM(cpy_r_r74); + if (unlikely(cpy_r_r81 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r82 = CPyModule_builtins; + cpy_r_r83 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'TypeError' */ + cpy_r_r84 = CPyObject_GetAttr(cpy_r_r82, cpy_r_r83); + if (unlikely(cpy_r_r84 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL57; + } + PyObject *cpy_r_r85[1] = {cpy_r_r81}; + cpy_r_r86 = (PyObject **)&cpy_r_r85; + cpy_r_r87 = PyObject_Vectorcall(cpy_r_r84, cpy_r_r86, 1, 0); + CPy_DECREF(cpy_r_r84); + if (unlikely(cpy_r_r87 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL57; + } + CPy_DECREF(cpy_r_r81); + CPy_Raise(cpy_r_r87); + CPy_DECREF(cpy_r_r87); + if (unlikely(!0)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL51; + } + CPy_Unreachable(); +CPyL51: ; + cpy_r_r88 = NULL; + return cpy_r_r88; +CPyL52: ; + CPy_DecRef(cpy_r_r29); + goto CPyL51; +CPyL53: ; + CPyTagged_DecRef(cpy_r_r36); + goto CPyL51; +CPyL54: ; + CPy_DecRef(cpy_r_r40); + goto CPyL51; +CPyL55: ; + CPy_DecRef(cpy_r_r64); + CPy_DecRef(cpy_r_r67); + goto CPyL51; +CPyL56: ; + CPy_DecRef(cpy_r_r64); + CPy_DecRef(cpy_r_r72); + goto CPyL51; +CPyL57: ; + CPy_DecRef(cpy_r_r81); + goto CPyL51; +} + +PyObject *CPyPy__utils___to_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"val", 0}; + static CPyArg_Parser parser = {"O:to_bytes", kwlist, 0}; + PyObject *obj_val; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_val)) { + return NULL; + } + PyObject *arg_val; + if (PyBytes_Check(obj_val) || PyByteArray_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL1; + if (PyUnicode_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL1; + arg_val = obj_val; + if (arg_val != NULL) goto __LL1; + if (PyBool_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL1; + if (PyLong_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL1; + CPy_TypeError("union[bytes, str, object, bool, int]", obj_val); + goto fail; +__LL1: ; + PyObject *retval = CPyDef__utils___to_bytes(arg_val); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + return NULL; +} + +PyObject *CPyDef__utils___hexstr_to_bytes(PyObject *cpy_r_hexstr) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + tuple_T2OO cpy_r_r2; + PyObject *cpy_r_r3; + char cpy_r_r4; + PyObject *cpy_r_r5; + PyObject *cpy_r_r6; + PyObject *cpy_r_non_prefixed_hex; + int64_t cpy_r_r7; + char cpy_r_r8; + CPyTagged cpy_r_r9; + CPyTagged cpy_r_r10; + char cpy_r_r11; + PyObject *cpy_r_r12; + PyObject *cpy_r_r13; + PyObject *cpy_r_padded_hex; + PyObject *cpy_r_r14; + tuple_T3OOO cpy_r_r15; + PyObject *cpy_r_r16; + PyObject *cpy_r_r17; + PyObject *cpy_r_r18; + char cpy_r_r19; + PyObject *cpy_r_r20; + PyObject *cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + PyObject *cpy_r_r24; + PyObject *cpy_r_r25; + PyObject **cpy_r_r27; + PyObject *cpy_r_r28; + char cpy_r_r29; + PyObject *cpy_r_r30; + char cpy_r_r31; + PyObject **cpy_r_r33; + PyObject *cpy_r_r34; + PyObject *cpy_r_r35; + PyObject *cpy_r_r36; + cpy_r_r0 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '0x' */ + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '0X' */ + CPy_INCREF(cpy_r_r0); + CPy_INCREF(cpy_r_r1); + cpy_r_r2.f0 = cpy_r_r0; + cpy_r_r2.f1 = cpy_r_r1; + cpy_r_r3 = PyTuple_New(2); + if (unlikely(cpy_r_r3 == NULL)) + CPyError_OutOfMemory(); + PyObject *__tmp2 = cpy_r_r2.f0; + PyTuple_SET_ITEM(cpy_r_r3, 0, __tmp2); + PyObject *__tmp3 = cpy_r_r2.f1; + PyTuple_SET_ITEM(cpy_r_r3, 1, __tmp3); + cpy_r_r4 = CPyStr_Startswith(cpy_r_hexstr, cpy_r_r3); + CPy_DECREF(cpy_r_r3); + if (unlikely(cpy_r_r4 == 2)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL31; + } + if (!cpy_r_r4) goto CPyL5; + cpy_r_r5 = CPyStr_GetSlice(cpy_r_hexstr, 4, 9223372036854775806LL); + if (unlikely(cpy_r_r5 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL31; + } + if (likely(PyUnicode_Check(cpy_r_r5))) + cpy_r_r6 = cpy_r_r5; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 41, CPyStatic__utils___globals, "str", cpy_r_r5); + goto CPyL31; + } + cpy_r_non_prefixed_hex = cpy_r_r6; + goto CPyL6; +CPyL5: ; + CPy_INCREF(cpy_r_hexstr); + cpy_r_non_prefixed_hex = cpy_r_hexstr; +CPyL6: ; + cpy_r_r7 = CPyStr_Size_size_t(cpy_r_hexstr); + cpy_r_r8 = cpy_r_r7 >= 0; + if (unlikely(!cpy_r_r8)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL32; + } + cpy_r_r9 = cpy_r_r7 << 1; + cpy_r_r10 = CPyTagged_Remainder(cpy_r_r9, 4); + if (unlikely(cpy_r_r10 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL32; + } + cpy_r_r11 = cpy_r_r10 != 0; + CPyTagged_DECREF(cpy_r_r10); + if (!cpy_r_r11) goto CPyL11; + cpy_r_r12 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '0' */ + cpy_r_r13 = PyUnicode_Concat(cpy_r_r12, cpy_r_non_prefixed_hex); + CPy_DECREF(cpy_r_non_prefixed_hex); + if (unlikely(cpy_r_r13 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL31; + } + cpy_r_padded_hex = cpy_r_r13; + goto CPyL12; +CPyL11: ; + cpy_r_padded_hex = cpy_r_non_prefixed_hex; +CPyL12: ; + cpy_r_r14 = PyUnicode_AsASCIIString(cpy_r_padded_hex); + if (unlikely(cpy_r_r14 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL14; + } else + goto CPyL33; +CPyL13: ; + goto CPyL25; +CPyL14: ; + cpy_r_r15 = CPy_CatchError(); + cpy_r_r16 = CPyModule_builtins; + cpy_r_r17 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'UnicodeDecodeError' */ + cpy_r_r18 = CPyObject_GetAttr(cpy_r_r16, cpy_r_r17); + if (unlikely(cpy_r_r18 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL34; + } + cpy_r_r19 = CPy_ExceptionMatches(cpy_r_r18); + CPy_DecRef(cpy_r_r18); + if (!cpy_r_r19) goto CPyL35; + cpy_r_r20 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'hex string ' */ + cpy_r_r21 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ' may only contain [0-9a-fA-F] characters' */ + cpy_r_r22 = CPyStr_Build(3, cpy_r_r20, cpy_r_padded_hex, cpy_r_r21); + CPy_DecRef(cpy_r_padded_hex); + if (unlikely(cpy_r_r22 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL23; + } + cpy_r_r23 = CPyModule_builtins; + cpy_r_r24 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'ValueError' */ + cpy_r_r25 = CPyObject_GetAttr(cpy_r_r23, cpy_r_r24); + if (unlikely(cpy_r_r25 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL36; + } + PyObject *cpy_r_r26[1] = {cpy_r_r22}; + cpy_r_r27 = (PyObject **)&cpy_r_r26; + cpy_r_r28 = PyObject_Vectorcall(cpy_r_r25, cpy_r_r27, 1, 0); + CPy_DecRef(cpy_r_r25); + if (unlikely(cpy_r_r28 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL36; + } + CPy_DecRef(cpy_r_r22); + CPy_Raise(cpy_r_r28); + CPy_DecRef(cpy_r_r28); + if (unlikely(!0)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL23; + } else + goto CPyL37; +CPyL20: ; + CPy_Unreachable(); +CPyL21: ; + CPy_Reraise(); + if (!0) { + goto CPyL23; + } else + goto CPyL38; +CPyL22: ; + CPy_Unreachable(); +CPyL23: ; + CPy_RestoreExcInfo(cpy_r_r15); + CPy_DecRef(cpy_r_r15.f0); + CPy_DecRef(cpy_r_r15.f1); + CPy_DecRef(cpy_r_r15.f2); + cpy_r_r29 = CPy_KeepPropagating(); + if (!cpy_r_r29) goto CPyL31; + CPy_Unreachable(); +CPyL25: ; + cpy_r_r30 = CPyStatic__utils___unhexlify; + if (unlikely(cpy_r_r30 == NULL)) { + goto CPyL39; + } else + goto CPyL28; +CPyL26: ; + PyErr_SetString(PyExc_NameError, "value for final name \"unhexlify\" was not set"); + cpy_r_r31 = 0; + if (unlikely(!cpy_r_r31)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL31; + } + CPy_Unreachable(); +CPyL28: ; + PyObject *cpy_r_r32[1] = {cpy_r_r14}; + cpy_r_r33 = (PyObject **)&cpy_r_r32; + cpy_r_r34 = PyObject_Vectorcall(cpy_r_r30, cpy_r_r33, 1, 0); + if (unlikely(cpy_r_r34 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL40; + } + CPy_DECREF(cpy_r_r14); + if (likely(PyBytes_Check(cpy_r_r34) || PyByteArray_Check(cpy_r_r34))) + cpy_r_r35 = cpy_r_r34; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 58, CPyStatic__utils___globals, "bytes", cpy_r_r34); + goto CPyL31; + } + return cpy_r_r35; +CPyL31: ; + cpy_r_r36 = NULL; + return cpy_r_r36; +CPyL32: ; + CPy_DecRef(cpy_r_non_prefixed_hex); + goto CPyL31; +CPyL33: ; + CPy_DECREF(cpy_r_padded_hex); + goto CPyL13; +CPyL34: ; + CPy_DecRef(cpy_r_padded_hex); + goto CPyL23; +CPyL35: ; + CPy_DecRef(cpy_r_padded_hex); + goto CPyL21; +CPyL36: ; + CPy_DecRef(cpy_r_r22); + goto CPyL23; +CPyL37: ; + CPy_DecRef(cpy_r_r15.f0); + CPy_DecRef(cpy_r_r15.f1); + CPy_DecRef(cpy_r_r15.f2); + goto CPyL20; +CPyL38: ; + CPy_DecRef(cpy_r_r15.f0); + CPy_DecRef(cpy_r_r15.f1); + CPy_DecRef(cpy_r_r15.f2); + goto CPyL22; +CPyL39: ; + CPy_DecRef(cpy_r_r14); + goto CPyL26; +CPyL40: ; + CPy_DecRef(cpy_r_r14); + goto CPyL31; +} + +PyObject *CPyPy__utils___hexstr_to_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"hexstr", 0}; + static CPyArg_Parser parser = {"O:hexstr_to_bytes", kwlist, 0}; + PyObject *obj_hexstr; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_hexstr)) { + return NULL; + } + PyObject *arg_hexstr; + if (likely(PyUnicode_Check(obj_hexstr))) + arg_hexstr = obj_hexstr; + else { + CPy_TypeError("str", obj_hexstr); + goto fail; + } + PyObject *retval = CPyDef__utils___hexstr_to_bytes(arg_hexstr); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + return NULL; +} + +char CPyDef__utils_____top_level__(void) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + char cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + PyObject **cpy_r_r5; + void *cpy_r_r7; + void *cpy_r_r9; + PyObject *cpy_r_r10; + PyObject *cpy_r_r11; + PyObject *cpy_r_r12; + PyObject *cpy_r_r13; + char cpy_r_r14; + PyObject *cpy_r_r15; + PyObject *cpy_r_r16; + PyObject *cpy_r_r17; + PyObject *cpy_r_r18; + PyObject *cpy_r_r19; + PyObject *cpy_r_r20; + PyObject *cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + int32_t cpy_r_r24; + char cpy_r_r25; + char cpy_r_r26; + cpy_r_r0 = CPyModule_builtins; + cpy_r_r1 = (PyObject *)&_Py_NoneStruct; + cpy_r_r2 = cpy_r_r0 != cpy_r_r1; + if (cpy_r_r2) goto CPyL3; + cpy_r_r3 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'builtins' */ + cpy_r_r4 = PyImport_Import(cpy_r_r3); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "", -1, CPyStatic__utils___globals); + goto CPyL8; + } + CPyModule_builtins = cpy_r_r4; + CPy_INCREF(CPyModule_builtins); + CPy_DECREF(cpy_r_r4); +CPyL3: ; + cpy_r_r5 = (PyObject **)&CPyModule_binascii; + PyObject **cpy_r_r6[1] = {cpy_r_r5}; + cpy_r_r7 = (void *)&cpy_r_r6; + int64_t cpy_r_r8[1] = {1}; + cpy_r_r9 = (void *)&cpy_r_r8; + cpy_r_r10 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* (('binascii', 'binascii', 'binascii'),) */ + cpy_r_r11 = CPyStatic__utils___globals; + cpy_r_r12 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes/_utils.py' */ + cpy_r_r13 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ + cpy_r_r14 = CPyImport_ImportMany(cpy_r_r10, cpy_r_r7, cpy_r_r11, cpy_r_r12, cpy_r_r13, cpy_r_r9); + if (!cpy_r_r14) goto CPyL8; + cpy_r_r15 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('Final', 'Union') */ + cpy_r_r16 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'typing' */ + cpy_r_r17 = CPyStatic__utils___globals; + cpy_r_r18 = CPyImport_ImportFromMany(cpy_r_r16, cpy_r_r15, cpy_r_r15, cpy_r_r17); + if (unlikely(cpy_r_r18 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL8; + } + CPyModule_typing = cpy_r_r18; + CPy_INCREF(CPyModule_typing); + CPy_DECREF(cpy_r_r18); + cpy_r_r19 = CPyModule_binascii; + cpy_r_r20 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'unhexlify' */ + cpy_r_r21 = CPyObject_GetAttr(cpy_r_r19, cpy_r_r20); + if (unlikely(cpy_r_r21 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL8; + } + CPyStatic__utils___unhexlify = cpy_r_r21; + CPy_INCREF(CPyStatic__utils___unhexlify); + cpy_r_r22 = CPyStatic__utils___globals; + cpy_r_r23 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'unhexlify' */ + cpy_r_r24 = CPyDict_SetItem(cpy_r_r22, cpy_r_r23, cpy_r_r21); + CPy_DECREF(cpy_r_r21); + cpy_r_r25 = cpy_r_r24 >= 0; + if (unlikely(!cpy_r_r25)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); + goto CPyL8; + } + return 1; +CPyL8: ; + cpy_r_r26 = 2; + return cpy_r_r26; +} + +static PyObject *CPyDunder___get__main_____new___3_HexBytes_obj(PyObject *self, PyObject *instance, PyObject *owner) { + instance = instance ? instance : Py_None; + return CPyDef_main_____new___3_HexBytes_obj_____get__(self, instance, owner); +} +PyObject *CPyDef_main_____mypyc___3__new___3_HexBytes_obj_setup(PyObject *cpy_r_type); +PyObject *CPyDef_main_____new___3_HexBytes_obj(void); + +static PyObject * +main_____new___3_HexBytes_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (type != CPyType_main_____new___3_HexBytes_obj) { + PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled"); + return NULL; + } + PyObject *self = CPyDef_main_____mypyc___3__new___3_HexBytes_obj_setup((PyObject*)type); + if (self == NULL) + return NULL; + return self; +} + +static int +main_____new___3_HexBytes_obj_traverse(faster_hexbytes___main_____new___3_HexBytes_objObject *self, visitproc visit, void *arg) +{ + return 0; +} + +static int +main_____new___3_HexBytes_obj_clear(faster_hexbytes___main_____new___3_HexBytes_objObject *self) +{ + return 0; +} + +static void +main_____new___3_HexBytes_obj_dealloc(faster_hexbytes___main_____new___3_HexBytes_objObject *self) +{ + PyObject_GC_UnTrack(self); + if (main_____new___3_HexBytes_obj_free_instance == NULL) { + main_____new___3_HexBytes_obj_free_instance = self; + return; + } + CPy_TRASHCAN_BEGIN(self, main_____new___3_HexBytes_obj_dealloc) + main_____new___3_HexBytes_obj_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); + CPy_TRASHCAN_END(self) +} + +static CPyVTableItem main_____new___3_HexBytes_obj_vtable[2]; +static bool +CPyDef_main_____new___3_HexBytes_obj_trait_vtable_setup(void) +{ + CPyVTableItem main_____new___3_HexBytes_obj_vtable_scratch[] = { + (CPyVTableItem)CPyDef_main_____new___3_HexBytes_obj_____call__, + (CPyVTableItem)CPyDef_main_____new___3_HexBytes_obj_____get__, + }; + memcpy(main_____new___3_HexBytes_obj_vtable, main_____new___3_HexBytes_obj_vtable_scratch, sizeof(main_____new___3_HexBytes_obj_vtable)); + return 1; +} + +static PyMethodDef main_____new___3_HexBytes_obj_methods[] = { + {"__call__", + (PyCFunction)CPyPy_main_____new___3_HexBytes_obj_____call__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__call__($cls, val)\n--\n\n")}, + {"__get__", + (PyCFunction)CPyPy_main_____new___3_HexBytes_obj_____get__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__get__($instance, owner)\n--\n\n")}, + {"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL}, + {"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject CPyType_main_____new___3_HexBytes_obj_template_ = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "__new___HexBytes_obj", + .tp_new = main_____new___3_HexBytes_obj_new, + .tp_dealloc = (destructor)main_____new___3_HexBytes_obj_dealloc, + .tp_traverse = (traverseproc)main_____new___3_HexBytes_obj_traverse, + .tp_clear = (inquiry)main_____new___3_HexBytes_obj_clear, + .tp_methods = main_____new___3_HexBytes_obj_methods, + .tp_call = PyVectorcall_Call, + .tp_descr_get = CPyDunder___get__main_____new___3_HexBytes_obj, + .tp_basicsize = sizeof(faster_hexbytes___main_____new___3_HexBytes_objObject), + .tp_vectorcall_offset = offsetof(faster_hexbytes___main_____new___3_HexBytes_objObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_HAVE_VECTORCALL, + .tp_doc = PyDoc_STR("__new___HexBytes_obj()\n--\n\n"), +}; +static PyTypeObject *CPyType_main_____new___3_HexBytes_obj_template = &CPyType_main_____new___3_HexBytes_obj_template_; + +PyObject *CPyDef_main_____mypyc___3__new___3_HexBytes_obj_setup(PyObject *cpy_r_type) +{ + PyTypeObject *type = (PyTypeObject*)cpy_r_type; + faster_hexbytes___main_____new___3_HexBytes_objObject *self; + if (main_____new___3_HexBytes_obj_free_instance != NULL) { + self = main_____new___3_HexBytes_obj_free_instance; + main_____new___3_HexBytes_obj_free_instance = NULL; + Py_SET_REFCNT(self, 1); + PyObject_GC_Track(self); + return (PyObject *)self; + } + self = (faster_hexbytes___main_____new___3_HexBytes_objObject *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + self->vtable = main_____new___3_HexBytes_obj_vtable; + self->vectorcall = CPyPy_main_____new___3_HexBytes_obj_____call__; + return (PyObject *)self; +} + +PyObject *CPyDef_main_____new___3_HexBytes_obj(void) +{ + PyObject *self = CPyDef_main_____mypyc___3__new___3_HexBytes_obj_setup((PyObject *)CPyType_main_____new___3_HexBytes_obj); + if (self == NULL) + return NULL; + return self; +} + + +static PyObject *CPyDunder___get__main_____getitem___3_HexBytes_obj(PyObject *self, PyObject *instance, PyObject *owner) { + instance = instance ? instance : Py_None; + return CPyDef_main_____getitem___3_HexBytes_obj_____get__(self, instance, owner); +} +PyObject *CPyDef_main_____mypyc___3__getitem___3_HexBytes_obj_setup(PyObject *cpy_r_type); +PyObject *CPyDef_main_____getitem___3_HexBytes_obj(void); + +static PyObject * +main_____getitem___3_HexBytes_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (type != CPyType_main_____getitem___3_HexBytes_obj) { + PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled"); + return NULL; + } + PyObject *self = CPyDef_main_____mypyc___3__getitem___3_HexBytes_obj_setup((PyObject*)type); + if (self == NULL) + return NULL; + return self; +} + +static int +main_____getitem___3_HexBytes_obj_traverse(faster_hexbytes___main_____getitem___3_HexBytes_objObject *self, visitproc visit, void *arg) +{ + return 0; +} + +static int +main_____getitem___3_HexBytes_obj_clear(faster_hexbytes___main_____getitem___3_HexBytes_objObject *self) +{ + return 0; +} + +static void +main_____getitem___3_HexBytes_obj_dealloc(faster_hexbytes___main_____getitem___3_HexBytes_objObject *self) +{ + PyObject_GC_UnTrack(self); + if (main_____getitem___3_HexBytes_obj_free_instance == NULL) { + main_____getitem___3_HexBytes_obj_free_instance = self; + return; + } + CPy_TRASHCAN_BEGIN(self, main_____getitem___3_HexBytes_obj_dealloc) + main_____getitem___3_HexBytes_obj_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); + CPy_TRASHCAN_END(self) +} + +static CPyVTableItem main_____getitem___3_HexBytes_obj_vtable[2]; +static bool +CPyDef_main_____getitem___3_HexBytes_obj_trait_vtable_setup(void) +{ + CPyVTableItem main_____getitem___3_HexBytes_obj_vtable_scratch[] = { + (CPyVTableItem)CPyDef_main_____getitem___3_HexBytes_obj_____call__, + (CPyVTableItem)CPyDef_main_____getitem___3_HexBytes_obj_____get__, + }; + memcpy(main_____getitem___3_HexBytes_obj_vtable, main_____getitem___3_HexBytes_obj_vtable_scratch, sizeof(main_____getitem___3_HexBytes_obj_vtable)); + return 1; +} + +static PyMethodDef main_____getitem___3_HexBytes_obj_methods[] = { + {"__call__", + (PyCFunction)CPyPy_main_____getitem___3_HexBytes_obj_____call__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__call__($self, key, /)\n--\n\n")}, + {"__get__", + (PyCFunction)CPyPy_main_____getitem___3_HexBytes_obj_____get__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__get__($instance, owner)\n--\n\n")}, + {"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL}, + {"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject CPyType_main_____getitem___3_HexBytes_obj_template_ = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "__getitem___HexBytes_obj", + .tp_new = main_____getitem___3_HexBytes_obj_new, + .tp_dealloc = (destructor)main_____getitem___3_HexBytes_obj_dealloc, + .tp_traverse = (traverseproc)main_____getitem___3_HexBytes_obj_traverse, + .tp_clear = (inquiry)main_____getitem___3_HexBytes_obj_clear, + .tp_methods = main_____getitem___3_HexBytes_obj_methods, + .tp_call = PyVectorcall_Call, + .tp_descr_get = CPyDunder___get__main_____getitem___3_HexBytes_obj, + .tp_basicsize = sizeof(faster_hexbytes___main_____getitem___3_HexBytes_objObject), + .tp_vectorcall_offset = offsetof(faster_hexbytes___main_____getitem___3_HexBytes_objObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_HAVE_VECTORCALL, + .tp_doc = PyDoc_STR("__getitem___HexBytes_obj()\n--\n\n"), +}; +static PyTypeObject *CPyType_main_____getitem___3_HexBytes_obj_template = &CPyType_main_____getitem___3_HexBytes_obj_template_; + +PyObject *CPyDef_main_____mypyc___3__getitem___3_HexBytes_obj_setup(PyObject *cpy_r_type) +{ + PyTypeObject *type = (PyTypeObject*)cpy_r_type; + faster_hexbytes___main_____getitem___3_HexBytes_objObject *self; + if (main_____getitem___3_HexBytes_obj_free_instance != NULL) { + self = main_____getitem___3_HexBytes_obj_free_instance; + main_____getitem___3_HexBytes_obj_free_instance = NULL; + Py_SET_REFCNT(self, 1); + PyObject_GC_Track(self); + return (PyObject *)self; + } + self = (faster_hexbytes___main_____getitem___3_HexBytes_objObject *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + self->vtable = main_____getitem___3_HexBytes_obj_vtable; + self->vectorcall = CPyPy_main_____getitem___3_HexBytes_obj_____call__; + return (PyObject *)self; +} + +PyObject *CPyDef_main_____getitem___3_HexBytes_obj(void) +{ + PyObject *self = CPyDef_main_____mypyc___3__getitem___3_HexBytes_obj_setup((PyObject *)CPyType_main_____getitem___3_HexBytes_obj); + if (self == NULL) + return NULL; + return self; +} + + +static PyObject *CPyDunder___get__main_____repr___3_HexBytes_obj(PyObject *self, PyObject *instance, PyObject *owner) { + instance = instance ? instance : Py_None; + return CPyDef_main_____repr___3_HexBytes_obj_____get__(self, instance, owner); +} +PyObject *CPyDef_main_____mypyc___3__repr___3_HexBytes_obj_setup(PyObject *cpy_r_type); +PyObject *CPyDef_main_____repr___3_HexBytes_obj(void); + +static PyObject * +main_____repr___3_HexBytes_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (type != CPyType_main_____repr___3_HexBytes_obj) { + PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled"); + return NULL; + } + PyObject *self = CPyDef_main_____mypyc___3__repr___3_HexBytes_obj_setup((PyObject*)type); + if (self == NULL) + return NULL; + return self; +} + +static int +main_____repr___3_HexBytes_obj_traverse(faster_hexbytes___main_____repr___3_HexBytes_objObject *self, visitproc visit, void *arg) +{ + return 0; +} + +static int +main_____repr___3_HexBytes_obj_clear(faster_hexbytes___main_____repr___3_HexBytes_objObject *self) +{ + return 0; +} + +static void +main_____repr___3_HexBytes_obj_dealloc(faster_hexbytes___main_____repr___3_HexBytes_objObject *self) +{ + PyObject_GC_UnTrack(self); + if (main_____repr___3_HexBytes_obj_free_instance == NULL) { + main_____repr___3_HexBytes_obj_free_instance = self; + return; + } + CPy_TRASHCAN_BEGIN(self, main_____repr___3_HexBytes_obj_dealloc) + main_____repr___3_HexBytes_obj_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); + CPy_TRASHCAN_END(self) +} + +static CPyVTableItem main_____repr___3_HexBytes_obj_vtable[2]; +static bool +CPyDef_main_____repr___3_HexBytes_obj_trait_vtable_setup(void) +{ + CPyVTableItem main_____repr___3_HexBytes_obj_vtable_scratch[] = { + (CPyVTableItem)CPyDef_main_____repr___3_HexBytes_obj_____call__, + (CPyVTableItem)CPyDef_main_____repr___3_HexBytes_obj_____get__, + }; + memcpy(main_____repr___3_HexBytes_obj_vtable, main_____repr___3_HexBytes_obj_vtable_scratch, sizeof(main_____repr___3_HexBytes_obj_vtable)); + return 1; +} + +static PyMethodDef main_____repr___3_HexBytes_obj_methods[] = { + {"__call__", + (PyCFunction)CPyPy_main_____repr___3_HexBytes_obj_____call__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__call__($self, /)\n--\n\n")}, + {"__get__", + (PyCFunction)CPyPy_main_____repr___3_HexBytes_obj_____get__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__get__($instance, owner)\n--\n\n")}, + {"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL}, + {"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject CPyType_main_____repr___3_HexBytes_obj_template_ = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "__repr___HexBytes_obj", + .tp_new = main_____repr___3_HexBytes_obj_new, + .tp_dealloc = (destructor)main_____repr___3_HexBytes_obj_dealloc, + .tp_traverse = (traverseproc)main_____repr___3_HexBytes_obj_traverse, + .tp_clear = (inquiry)main_____repr___3_HexBytes_obj_clear, + .tp_methods = main_____repr___3_HexBytes_obj_methods, + .tp_call = PyVectorcall_Call, + .tp_descr_get = CPyDunder___get__main_____repr___3_HexBytes_obj, + .tp_basicsize = sizeof(faster_hexbytes___main_____repr___3_HexBytes_objObject), + .tp_vectorcall_offset = offsetof(faster_hexbytes___main_____repr___3_HexBytes_objObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_HAVE_VECTORCALL, + .tp_doc = PyDoc_STR("__repr___HexBytes_obj()\n--\n\n"), +}; +static PyTypeObject *CPyType_main_____repr___3_HexBytes_obj_template = &CPyType_main_____repr___3_HexBytes_obj_template_; + +PyObject *CPyDef_main_____mypyc___3__repr___3_HexBytes_obj_setup(PyObject *cpy_r_type) +{ + PyTypeObject *type = (PyTypeObject*)cpy_r_type; + faster_hexbytes___main_____repr___3_HexBytes_objObject *self; + if (main_____repr___3_HexBytes_obj_free_instance != NULL) { + self = main_____repr___3_HexBytes_obj_free_instance; + main_____repr___3_HexBytes_obj_free_instance = NULL; + Py_SET_REFCNT(self, 1); + PyObject_GC_Track(self); + return (PyObject *)self; + } + self = (faster_hexbytes___main_____repr___3_HexBytes_objObject *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + self->vtable = main_____repr___3_HexBytes_obj_vtable; + self->vectorcall = CPyPy_main_____repr___3_HexBytes_obj_____call__; + return (PyObject *)self; +} + +PyObject *CPyDef_main_____repr___3_HexBytes_obj(void) +{ + PyObject *self = CPyDef_main_____mypyc___3__repr___3_HexBytes_obj_setup((PyObject *)CPyType_main_____repr___3_HexBytes_obj); + if (self == NULL) + return NULL; + return self; +} + + +static PyObject *CPyDunder___get__main___to_0x_hex_HexBytes_obj(PyObject *self, PyObject *instance, PyObject *owner) { + instance = instance ? instance : Py_None; + return CPyDef_main___to_0x_hex_HexBytes_obj_____get__(self, instance, owner); +} +PyObject *CPyDef_main_____mypyc__to_0x_hex_HexBytes_obj_setup(PyObject *cpy_r_type); +PyObject *CPyDef_main___to_0x_hex_HexBytes_obj(void); + +static PyObject * +main___to_0x_hex_HexBytes_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (type != CPyType_main___to_0x_hex_HexBytes_obj) { + PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled"); + return NULL; + } + PyObject *self = CPyDef_main_____mypyc__to_0x_hex_HexBytes_obj_setup((PyObject*)type); + if (self == NULL) + return NULL; + return self; +} + +static int +main___to_0x_hex_HexBytes_obj_traverse(faster_hexbytes___main___to_0x_hex_HexBytes_objObject *self, visitproc visit, void *arg) +{ + return 0; +} + +static int +main___to_0x_hex_HexBytes_obj_clear(faster_hexbytes___main___to_0x_hex_HexBytes_objObject *self) +{ + return 0; +} + +static void +main___to_0x_hex_HexBytes_obj_dealloc(faster_hexbytes___main___to_0x_hex_HexBytes_objObject *self) +{ + PyObject_GC_UnTrack(self); + if (main___to_0x_hex_HexBytes_obj_free_instance == NULL) { + main___to_0x_hex_HexBytes_obj_free_instance = self; + return; + } + CPy_TRASHCAN_BEGIN(self, main___to_0x_hex_HexBytes_obj_dealloc) + main___to_0x_hex_HexBytes_obj_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); + CPy_TRASHCAN_END(self) +} + +static CPyVTableItem main___to_0x_hex_HexBytes_obj_vtable[2]; +static bool +CPyDef_main___to_0x_hex_HexBytes_obj_trait_vtable_setup(void) +{ + CPyVTableItem main___to_0x_hex_HexBytes_obj_vtable_scratch[] = { + (CPyVTableItem)CPyDef_main___to_0x_hex_HexBytes_obj_____call__, + (CPyVTableItem)CPyDef_main___to_0x_hex_HexBytes_obj_____get__, + }; + memcpy(main___to_0x_hex_HexBytes_obj_vtable, main___to_0x_hex_HexBytes_obj_vtable_scratch, sizeof(main___to_0x_hex_HexBytes_obj_vtable)); + return 1; +} + +static PyMethodDef main___to_0x_hex_HexBytes_obj_methods[] = { + {"__call__", + (PyCFunction)CPyPy_main___to_0x_hex_HexBytes_obj_____call__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__call__($self)\n--\n\n")}, + {"__get__", + (PyCFunction)CPyPy_main___to_0x_hex_HexBytes_obj_____get__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__get__($instance, owner)\n--\n\n")}, + {"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL}, + {"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject CPyType_main___to_0x_hex_HexBytes_obj_template_ = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "to_0x_hex_HexBytes_obj", + .tp_new = main___to_0x_hex_HexBytes_obj_new, + .tp_dealloc = (destructor)main___to_0x_hex_HexBytes_obj_dealloc, + .tp_traverse = (traverseproc)main___to_0x_hex_HexBytes_obj_traverse, + .tp_clear = (inquiry)main___to_0x_hex_HexBytes_obj_clear, + .tp_methods = main___to_0x_hex_HexBytes_obj_methods, + .tp_call = PyVectorcall_Call, + .tp_descr_get = CPyDunder___get__main___to_0x_hex_HexBytes_obj, + .tp_basicsize = sizeof(faster_hexbytes___main___to_0x_hex_HexBytes_objObject), + .tp_vectorcall_offset = offsetof(faster_hexbytes___main___to_0x_hex_HexBytes_objObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_HAVE_VECTORCALL, + .tp_doc = PyDoc_STR("to_0x_hex_HexBytes_obj()\n--\n\n"), +}; +static PyTypeObject *CPyType_main___to_0x_hex_HexBytes_obj_template = &CPyType_main___to_0x_hex_HexBytes_obj_template_; + +PyObject *CPyDef_main_____mypyc__to_0x_hex_HexBytes_obj_setup(PyObject *cpy_r_type) +{ + PyTypeObject *type = (PyTypeObject*)cpy_r_type; + faster_hexbytes___main___to_0x_hex_HexBytes_objObject *self; + if (main___to_0x_hex_HexBytes_obj_free_instance != NULL) { + self = main___to_0x_hex_HexBytes_obj_free_instance; + main___to_0x_hex_HexBytes_obj_free_instance = NULL; + Py_SET_REFCNT(self, 1); + PyObject_GC_Track(self); + return (PyObject *)self; + } + self = (faster_hexbytes___main___to_0x_hex_HexBytes_objObject *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + self->vtable = main___to_0x_hex_HexBytes_obj_vtable; + self->vectorcall = CPyPy_main___to_0x_hex_HexBytes_obj_____call__; + return (PyObject *)self; +} + +PyObject *CPyDef_main___to_0x_hex_HexBytes_obj(void) +{ + PyObject *self = CPyDef_main_____mypyc__to_0x_hex_HexBytes_obj_setup((PyObject *)CPyType_main___to_0x_hex_HexBytes_obj); + if (self == NULL) + return NULL; + return self; +} + + +static PyObject *CPyDunder___get__main_____reduce___3_HexBytes_obj(PyObject *self, PyObject *instance, PyObject *owner) { + instance = instance ? instance : Py_None; + return CPyDef_main_____reduce___3_HexBytes_obj_____get__(self, instance, owner); +} +PyObject *CPyDef_main_____mypyc___3__reduce___3_HexBytes_obj_setup(PyObject *cpy_r_type); +PyObject *CPyDef_main_____reduce___3_HexBytes_obj(void); + +static PyObject * +main_____reduce___3_HexBytes_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (type != CPyType_main_____reduce___3_HexBytes_obj) { + PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled"); + return NULL; + } + PyObject *self = CPyDef_main_____mypyc___3__reduce___3_HexBytes_obj_setup((PyObject*)type); + if (self == NULL) + return NULL; + return self; +} + +static int +main_____reduce___3_HexBytes_obj_traverse(faster_hexbytes___main_____reduce___3_HexBytes_objObject *self, visitproc visit, void *arg) +{ + return 0; +} + +static int +main_____reduce___3_HexBytes_obj_clear(faster_hexbytes___main_____reduce___3_HexBytes_objObject *self) +{ + return 0; +} + +static void +main_____reduce___3_HexBytes_obj_dealloc(faster_hexbytes___main_____reduce___3_HexBytes_objObject *self) +{ + PyObject_GC_UnTrack(self); + if (main_____reduce___3_HexBytes_obj_free_instance == NULL) { + main_____reduce___3_HexBytes_obj_free_instance = self; + return; + } + CPy_TRASHCAN_BEGIN(self, main_____reduce___3_HexBytes_obj_dealloc) + main_____reduce___3_HexBytes_obj_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); + CPy_TRASHCAN_END(self) +} + +static CPyVTableItem main_____reduce___3_HexBytes_obj_vtable[2]; +static bool +CPyDef_main_____reduce___3_HexBytes_obj_trait_vtable_setup(void) +{ + CPyVTableItem main_____reduce___3_HexBytes_obj_vtable_scratch[] = { + (CPyVTableItem)CPyDef_main_____reduce___3_HexBytes_obj_____call__, + (CPyVTableItem)CPyDef_main_____reduce___3_HexBytes_obj_____get__, + }; + memcpy(main_____reduce___3_HexBytes_obj_vtable, main_____reduce___3_HexBytes_obj_vtable_scratch, sizeof(main_____reduce___3_HexBytes_obj_vtable)); + return 1; +} + +static PyMethodDef main_____reduce___3_HexBytes_obj_methods[] = { + {"__call__", + (PyCFunction)CPyPy_main_____reduce___3_HexBytes_obj_____call__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__call__($self)\n--\n\n")}, + {"__get__", + (PyCFunction)CPyPy_main_____reduce___3_HexBytes_obj_____get__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__get__($instance, owner)\n--\n\n")}, + {"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL}, + {"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject CPyType_main_____reduce___3_HexBytes_obj_template_ = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "__reduce___HexBytes_obj", + .tp_new = main_____reduce___3_HexBytes_obj_new, + .tp_dealloc = (destructor)main_____reduce___3_HexBytes_obj_dealloc, + .tp_traverse = (traverseproc)main_____reduce___3_HexBytes_obj_traverse, + .tp_clear = (inquiry)main_____reduce___3_HexBytes_obj_clear, + .tp_methods = main_____reduce___3_HexBytes_obj_methods, + .tp_call = PyVectorcall_Call, + .tp_descr_get = CPyDunder___get__main_____reduce___3_HexBytes_obj, + .tp_basicsize = sizeof(faster_hexbytes___main_____reduce___3_HexBytes_objObject), + .tp_vectorcall_offset = offsetof(faster_hexbytes___main_____reduce___3_HexBytes_objObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_HAVE_VECTORCALL, + .tp_doc = PyDoc_STR("__reduce___HexBytes_obj()\n--\n\n"), +}; +static PyTypeObject *CPyType_main_____reduce___3_HexBytes_obj_template = &CPyType_main_____reduce___3_HexBytes_obj_template_; + +PyObject *CPyDef_main_____mypyc___3__reduce___3_HexBytes_obj_setup(PyObject *cpy_r_type) +{ + PyTypeObject *type = (PyTypeObject*)cpy_r_type; + faster_hexbytes___main_____reduce___3_HexBytes_objObject *self; + if (main_____reduce___3_HexBytes_obj_free_instance != NULL) { + self = main_____reduce___3_HexBytes_obj_free_instance; + main_____reduce___3_HexBytes_obj_free_instance = NULL; + Py_SET_REFCNT(self, 1); + PyObject_GC_Track(self); + return (PyObject *)self; + } + self = (faster_hexbytes___main_____reduce___3_HexBytes_objObject *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + self->vtable = main_____reduce___3_HexBytes_obj_vtable; + self->vectorcall = CPyPy_main_____reduce___3_HexBytes_obj_____call__; + return (PyObject *)self; +} + +PyObject *CPyDef_main_____reduce___3_HexBytes_obj(void) +{ + PyObject *self = CPyDef_main_____mypyc___3__reduce___3_HexBytes_obj_setup((PyObject *)CPyType_main_____reduce___3_HexBytes_obj); + if (self == NULL) + return NULL; + return self; +} + +static PyMethodDef mainmodule_methods[] = { + {NULL, NULL, 0, NULL} +}; + +int CPyExec_faster_hexbytes___main(PyObject *module) +{ + PyObject* modname = NULL; + modname = PyObject_GetAttrString((PyObject *)CPyModule_faster_hexbytes___main__internal, "__name__"); + CPyStatic_main___globals = PyModule_GetDict(CPyModule_faster_hexbytes___main__internal); + if (unlikely(CPyStatic_main___globals == NULL)) + goto fail; + CPyType_main_____new___3_HexBytes_obj = (PyTypeObject *)CPyType_FromTemplate((PyObject *)CPyType_main_____new___3_HexBytes_obj_template, NULL, modname); + if (unlikely(!CPyType_main_____new___3_HexBytes_obj)) + goto fail; + CPyType_main_____getitem___3_HexBytes_obj = (PyTypeObject *)CPyType_FromTemplate((PyObject *)CPyType_main_____getitem___3_HexBytes_obj_template, NULL, modname); + if (unlikely(!CPyType_main_____getitem___3_HexBytes_obj)) + goto fail; + CPyType_main_____repr___3_HexBytes_obj = (PyTypeObject *)CPyType_FromTemplate((PyObject *)CPyType_main_____repr___3_HexBytes_obj_template, NULL, modname); + if (unlikely(!CPyType_main_____repr___3_HexBytes_obj)) + goto fail; + CPyType_main___to_0x_hex_HexBytes_obj = (PyTypeObject *)CPyType_FromTemplate((PyObject *)CPyType_main___to_0x_hex_HexBytes_obj_template, NULL, modname); + if (unlikely(!CPyType_main___to_0x_hex_HexBytes_obj)) + goto fail; + CPyType_main_____reduce___3_HexBytes_obj = (PyTypeObject *)CPyType_FromTemplate((PyObject *)CPyType_main_____reduce___3_HexBytes_obj_template, NULL, modname); + if (unlikely(!CPyType_main_____reduce___3_HexBytes_obj)) + goto fail; + if (CPyGlobalsInit() < 0) + goto fail; + char result = CPyDef_main_____top_level__(); + if (result == 2) + goto fail; + Py_DECREF(modname); + return 0; + fail: + Py_CLEAR(CPyModule_faster_hexbytes___main__internal); + Py_CLEAR(modname); + CPy_XDECREF(CPyStatic_main____bytes_new); + CPyStatic_main____bytes_new = NULL; + Py_CLEAR(CPyType_main___HexBytes); + Py_CLEAR(CPyType_main____HexBytesSubclass1); + Py_CLEAR(CPyType_main____HexBytesSubclass2); + Py_CLEAR(CPyType_main____HexBytesSubclass3); + Py_CLEAR(CPyType_main_____new___3_HexBytes_obj); + Py_CLEAR(CPyType_main_____getitem___3_HexBytes_obj); + Py_CLEAR(CPyType_main_____repr___3_HexBytes_obj); + Py_CLEAR(CPyType_main___to_0x_hex_HexBytes_obj); + Py_CLEAR(CPyType_main_____reduce___3_HexBytes_obj); + return -1; +} +static struct PyModuleDef mainmodule = { + PyModuleDef_HEAD_INIT, + "faster_hexbytes.main", + NULL, /* docstring */ + 0, /* size of per-interpreter state of the module */ + mainmodule_methods, + NULL, +}; + +PyObject *CPyInit_faster_hexbytes___main(void) +{ + if (CPyModule_faster_hexbytes___main__internal) { + Py_INCREF(CPyModule_faster_hexbytes___main__internal); + return CPyModule_faster_hexbytes___main__internal; + } + CPyModule_faster_hexbytes___main__internal = PyModule_Create(&mainmodule); + if (unlikely(CPyModule_faster_hexbytes___main__internal == NULL)) + goto fail; + if (CPyExec_faster_hexbytes___main(CPyModule_faster_hexbytes___main__internal) != 0) + goto fail; + return CPyModule_faster_hexbytes___main__internal; + fail: + return NULL; +} + +PyObject *CPyDef_main_____new___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner) { + PyObject *cpy_r_r0; + char cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + cpy_r_r0 = (PyObject *)&_Py_NoneStruct; + cpy_r_r1 = cpy_r_instance == cpy_r_r0; + if (!cpy_r_r1) goto CPyL2; + CPy_INCREF(cpy_r___mypyc_self__); + return cpy_r___mypyc_self__; +CPyL2: ; + cpy_r_r2 = PyMethod_New(cpy_r___mypyc_self__, cpy_r_instance); + if (cpy_r_r2 == NULL) goto CPyL4; + return cpy_r_r2; +CPyL4: ; + cpy_r_r3 = NULL; + return cpy_r_r3; +} + +PyObject *CPyPy_main_____new___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"instance", "owner", 0}; + static CPyArg_Parser parser = {"OO:__get__", kwlist, 0}; + PyObject *obj_instance; + PyObject *obj_owner; + if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_instance, &obj_owner)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_instance = obj_instance; + PyObject *arg_owner = obj_owner; + PyObject *retval = CPyDef_main_____new___3_HexBytes_obj_____get__(arg___mypyc_self__, arg_instance, arg_owner); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__get__", -1, CPyStatic_main___globals); + return NULL; +} + +PyObject *CPyDef_main_____new___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_val) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + char cpy_r_r2; + PyObject **cpy_r_r4; + PyObject *cpy_r_r5; + PyObject *cpy_r_r6; + PyObject *cpy_r_r7; + cpy_r_r0 = CPyDef__utils___to_bytes(cpy_r_val); + if (unlikely(cpy_r_r0 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL7; + } + cpy_r_r1 = CPyStatic_main____bytes_new; + if (unlikely(cpy_r_r1 == NULL)) { + goto CPyL8; + } else + goto CPyL4; +CPyL2: ; + PyErr_SetString(PyExc_NameError, "value for final name \"_bytes_new\" was not set"); + cpy_r_r2 = 0; + if (unlikely(!cpy_r_r2)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL7; + } + CPy_Unreachable(); +CPyL4: ; + PyObject *cpy_r_r3[2] = {cpy_r_cls, cpy_r_r0}; + cpy_r_r4 = (PyObject **)&cpy_r_r3; + cpy_r_r5 = PyObject_Vectorcall(cpy_r_r1, cpy_r_r4, 2, 0); + if (unlikely(cpy_r_r5 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL9; + } + CPy_DECREF(cpy_r_r0); + if (likely(PyObject_TypeCheck(cpy_r_r5, CPyType_main___HexBytes))) + cpy_r_r6 = cpy_r_r5; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__new__", 51, CPyStatic_main___globals, "faster_hexbytes.main.HexBytes", cpy_r_r5); + goto CPyL7; + } + return cpy_r_r6; +CPyL7: ; + cpy_r_r7 = NULL; + return cpy_r_r7; +CPyL8: ; + CPy_DecRef(cpy_r_r0); + goto CPyL2; +CPyL9: ; + CPy_DecRef(cpy_r_r0); + goto CPyL7; +} + +PyObject *CPyPy_main_____new___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"cls", "val", 0}; + static CPyArg_Parser parser = {"OO:__call__", kwlist, 0}; + PyObject *obj_cls; + PyObject *obj_val; + if (!CPyArg_ParseStackAndKeywordsSimple(args, PyVectorcall_NARGS(nargs), kwnames, &parser, &obj_cls, &obj_val)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_cls = obj_cls; + PyObject *arg_val; + if (PyBytes_Check(obj_val) || PyByteArray_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL4; + if (PyUnicode_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL4; + if (PyBool_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL4; + arg_val = obj_val; + if (arg_val != NULL) goto __LL4; + if (PyLong_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL4; + CPy_TypeError("union[bytes, str, bool, object, int]", obj_val); + goto fail; +__LL4: ; + PyObject *retval = CPyDef_main_____new___3_HexBytes_obj_____call__(arg___mypyc_self__, arg_cls, arg_val); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + return NULL; +} + +PyObject *CPyDef_main_____getitem___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner) { + PyObject *cpy_r_r0; + char cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + cpy_r_r0 = (PyObject *)&_Py_NoneStruct; + cpy_r_r1 = cpy_r_instance == cpy_r_r0; + if (!cpy_r_r1) goto CPyL2; + CPy_INCREF(cpy_r___mypyc_self__); + return cpy_r___mypyc_self__; +CPyL2: ; + cpy_r_r2 = PyMethod_New(cpy_r___mypyc_self__, cpy_r_instance); + if (cpy_r_r2 == NULL) goto CPyL4; + return cpy_r_r2; +CPyL4: ; + cpy_r_r3 = NULL; + return cpy_r_r3; +} + +PyObject *CPyPy_main_____getitem___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"instance", "owner", 0}; + static CPyArg_Parser parser = {"OO:__get__", kwlist, 0}; + PyObject *obj_instance; + PyObject *obj_owner; + if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_instance, &obj_owner)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_instance = obj_instance; + PyObject *arg_owner = obj_owner; + PyObject *retval = CPyDef_main_____getitem___3_HexBytes_obj_____get__(arg___mypyc_self__, arg_instance, arg_owner); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__get__", -1, CPyStatic_main___globals); + return NULL; +} + +PyObject *CPyDef_main_____getitem___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self, PyObject *cpy_r_key) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject **cpy_r_r3; + PyObject *cpy_r_r4; + PyObject *cpy_r_r5; + char cpy_r_r6; + CPyTagged cpy_r_r7; + PyObject *cpy_r_r8; + PyObject *cpy_r_r9; + PyObject *cpy_r_r10; + char cpy_r_r11; + PyObject *cpy_r_r12; + PyObject *cpy_r_r13; + PyObject **cpy_r_r15; + PyObject *cpy_r_r16; + PyObject *cpy_r_r17; + PyObject *cpy_r_r18; + PyObject **cpy_r_r20; + PyObject *cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + cpy_r_r0 = (PyObject *)&PyBytes_Type; + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__getitem__' */ + PyObject *cpy_r_r2[3] = {cpy_r_r0, cpy_r_self, cpy_r_key}; + cpy_r_r3 = (PyObject **)&cpy_r_r2; + cpy_r_r4 = PyObject_VectorcallMethod(cpy_r_r1, cpy_r_r3, 9223372036854775811ULL, 0); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL14; + } + if (PyLong_Check(cpy_r_r4)) + cpy_r_r5 = cpy_r_r4; + else { + cpy_r_r5 = NULL; + } + if (cpy_r_r5 != NULL) goto __LL5; + if (PyBytes_Check(cpy_r_r4) || PyByteArray_Check(cpy_r_r4)) + cpy_r_r5 = cpy_r_r4; + else { + cpy_r_r5 = NULL; + } + if (cpy_r_r5 != NULL) goto __LL5; + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 64, CPyStatic_main___globals, "union[int, bytes]", cpy_r_r4); + goto CPyL14; +__LL5: ; + cpy_r_r6 = PyLong_Check(cpy_r_r5); + if (!cpy_r_r6) goto CPyL5; + if (likely(PyLong_Check(cpy_r_r5))) + cpy_r_r7 = CPyTagged_FromObject(cpy_r_r5); + else { + CPy_TypeError("int", cpy_r_r5); cpy_r_r7 = CPY_INT_TAG; + } + CPy_DECREF(cpy_r_r5); + if (unlikely(cpy_r_r7 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL14; + } + cpy_r_r8 = CPyTagged_StealAsObject(cpy_r_r7); + return cpy_r_r8; +CPyL5: ; + cpy_r_r9 = CPy_TYPE(cpy_r_self); + cpy_r_r10 = (PyObject *)CPyType_main___HexBytes; + cpy_r_r11 = cpy_r_r9 == cpy_r_r10; + if (cpy_r_r11) { + goto CPyL15; + } else + goto CPyL10; +CPyL6: ; + if (likely(PyBytes_Check(cpy_r_r5) || PyByteArray_Check(cpy_r_r5))) + cpy_r_r12 = cpy_r_r5; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 70, CPyStatic_main___globals, "bytes", cpy_r_r5); + goto CPyL14; + } + cpy_r_r13 = (PyObject *)CPyType_main___HexBytes; + PyObject *cpy_r_r14[1] = {cpy_r_r12}; + cpy_r_r15 = (PyObject **)&cpy_r_r14; + cpy_r_r16 = PyObject_Vectorcall(cpy_r_r13, cpy_r_r15, 1, 0); + if (unlikely(cpy_r_r16 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL16; + } + CPy_DECREF(cpy_r_r12); + if (likely(PyObject_TypeCheck(cpy_r_r16, CPyType_main___HexBytes))) + cpy_r_r17 = cpy_r_r16; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 70, CPyStatic_main___globals, "faster_hexbytes.main.HexBytes", cpy_r_r16); + goto CPyL14; + } + return cpy_r_r17; +CPyL10: ; + if (likely(PyBytes_Check(cpy_r_r5) || PyByteArray_Check(cpy_r_r5))) + cpy_r_r18 = cpy_r_r5; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 71, CPyStatic_main___globals, "bytes", cpy_r_r5); + goto CPyL17; + } + PyObject *cpy_r_r19[1] = {cpy_r_r18}; + cpy_r_r20 = (PyObject **)&cpy_r_r19; + cpy_r_r21 = PyObject_Vectorcall(cpy_r_r9, cpy_r_r20, 1, 0); + CPy_DECREF(cpy_r_r9); + if (unlikely(cpy_r_r21 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL18; + } + CPy_DECREF(cpy_r_r18); + if (likely(PyObject_TypeCheck(cpy_r_r21, CPyType_main___HexBytes))) + cpy_r_r22 = cpy_r_r21; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 71, CPyStatic_main___globals, "faster_hexbytes.main.HexBytes", cpy_r_r21); + goto CPyL14; + } + return cpy_r_r22; +CPyL14: ; + cpy_r_r23 = NULL; + return cpy_r_r23; +CPyL15: ; + CPy_DECREF(cpy_r_r9); + goto CPyL6; +CPyL16: ; + CPy_DecRef(cpy_r_r12); + goto CPyL14; +CPyL17: ; + CPy_DecRef(cpy_r_r9); + goto CPyL14; +CPyL18: ; + CPy_DecRef(cpy_r_r18); + goto CPyL14; +} + +PyObject *CPyPy_main_____getitem___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"self", "key", 0}; + static CPyArg_Parser parser = {"OO:__call__", kwlist, 0}; + PyObject *obj_self; + PyObject *obj_key; + if (!CPyArg_ParseStackAndKeywordsSimple(args, PyVectorcall_NARGS(nargs), kwnames, &parser, &obj_self, &obj_key)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_self; + if (likely(PyObject_TypeCheck(obj_self, CPyType_main___HexBytes))) + arg_self = obj_self; + else { + CPy_TypeError("faster_hexbytes.main.HexBytes", obj_self); + goto fail; + } + PyObject *arg_key = obj_key; + PyObject *retval = CPyDef_main_____getitem___3_HexBytes_obj_____call__(arg___mypyc_self__, arg_self, arg_key); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + return NULL; +} + +PyObject *CPyDef_main_____repr___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner) { + PyObject *cpy_r_r0; + char cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + cpy_r_r0 = (PyObject *)&_Py_NoneStruct; + cpy_r_r1 = cpy_r_instance == cpy_r_r0; + if (!cpy_r_r1) goto CPyL2; + CPy_INCREF(cpy_r___mypyc_self__); + return cpy_r___mypyc_self__; +CPyL2: ; + cpy_r_r2 = PyMethod_New(cpy_r___mypyc_self__, cpy_r_instance); + if (cpy_r_r2 == NULL) goto CPyL4; + return cpy_r_r2; +CPyL4: ; + cpy_r_r3 = NULL; + return cpy_r_r3; +} + +PyObject *CPyPy_main_____repr___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"instance", "owner", 0}; + static CPyArg_Parser parser = {"OO:__get__", kwlist, 0}; + PyObject *obj_instance; + PyObject *obj_owner; + if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_instance, &obj_owner)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_instance = obj_instance; + PyObject *arg_owner = obj_owner; + PyObject *retval = CPyDef_main_____repr___3_HexBytes_obj_____get__(arg___mypyc_self__, arg_instance, arg_owner); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__get__", -1, CPyStatic_main___globals); + return NULL; +} + +PyObject *CPyDef_main_____repr___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject **cpy_r_r3; + PyObject *cpy_r_r4; + PyObject *cpy_r_r5; + PyObject *cpy_r_r6; + PyObject *cpy_r_r7; + PyObject *cpy_r_r8; + cpy_r_r0 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* "HexBytes('0x" */ + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'hex' */ + PyObject *cpy_r_r2[1] = {cpy_r_self}; + cpy_r_r3 = (PyObject **)&cpy_r_r2; + cpy_r_r4 = PyObject_VectorcallMethod(cpy_r_r1, cpy_r_r3, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL4; + } + if (likely(PyUnicode_Check(cpy_r_r4))) + cpy_r_r5 = cpy_r_r4; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 74, CPyStatic_main___globals, "str", cpy_r_r4); + goto CPyL4; + } + cpy_r_r6 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* "')" */ + cpy_r_r7 = CPyStr_Build(3, cpy_r_r0, cpy_r_r5, cpy_r_r6); + CPy_DECREF(cpy_r_r5); + if (unlikely(cpy_r_r7 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL4; + } + return cpy_r_r7; +CPyL4: ; + cpy_r_r8 = NULL; + return cpy_r_r8; +} + +PyObject *CPyPy_main_____repr___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"self", 0}; + static CPyArg_Parser parser = {"O:__call__", kwlist, 0}; + PyObject *obj_self; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, PyVectorcall_NARGS(nargs), kwnames, &parser, &obj_self)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_self; + if (likely(PyObject_TypeCheck(obj_self, CPyType_main___HexBytes))) + arg_self = obj_self; + else { + CPy_TypeError("faster_hexbytes.main.HexBytes", obj_self); + goto fail; + } + PyObject *retval = CPyDef_main_____repr___3_HexBytes_obj_____call__(arg___mypyc_self__, arg_self); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + return NULL; +} + +PyObject *CPyDef_main___to_0x_hex_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner) { + PyObject *cpy_r_r0; + char cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + cpy_r_r0 = (PyObject *)&_Py_NoneStruct; + cpy_r_r1 = cpy_r_instance == cpy_r_r0; + if (!cpy_r_r1) goto CPyL2; + CPy_INCREF(cpy_r___mypyc_self__); + return cpy_r___mypyc_self__; +CPyL2: ; + cpy_r_r2 = PyMethod_New(cpy_r___mypyc_self__, cpy_r_instance); + if (cpy_r_r2 == NULL) goto CPyL4; + return cpy_r_r2; +CPyL4: ; + cpy_r_r3 = NULL; + return cpy_r_r3; +} + +PyObject *CPyPy_main___to_0x_hex_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"instance", "owner", 0}; + static CPyArg_Parser parser = {"OO:__get__", kwlist, 0}; + PyObject *obj_instance; + PyObject *obj_owner; + if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_instance, &obj_owner)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_instance = obj_instance; + PyObject *arg_owner = obj_owner; + PyObject *retval = CPyDef_main___to_0x_hex_HexBytes_obj_____get__(arg___mypyc_self__, arg_instance, arg_owner); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__get__", -1, CPyStatic_main___globals); + return NULL; +} + +PyObject *CPyDef_main___to_0x_hex_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject **cpy_r_r3; + PyObject *cpy_r_r4; + PyObject *cpy_r_r5; + PyObject *cpy_r_r6; + PyObject *cpy_r_r7; + cpy_r_r0 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '0x' */ + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'hex' */ + PyObject *cpy_r_r2[1] = {cpy_r_self}; + cpy_r_r3 = (PyObject **)&cpy_r_r2; + cpy_r_r4 = PyObject_VectorcallMethod(cpy_r_r1, cpy_r_r3, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "to_0x_hex", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL4; + } + if (likely(PyUnicode_Check(cpy_r_r4))) + cpy_r_r5 = cpy_r_r4; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "to_0x_hex", 80, CPyStatic_main___globals, "str", cpy_r_r4); + goto CPyL4; + } + cpy_r_r6 = CPyStr_Build(2, cpy_r_r0, cpy_r_r5); + CPy_DECREF(cpy_r_r5); + if (unlikely(cpy_r_r6 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "to_0x_hex", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL4; + } + return cpy_r_r6; +CPyL4: ; + cpy_r_r7 = NULL; + return cpy_r_r7; +} + +PyObject *CPyPy_main___to_0x_hex_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"self", 0}; + static CPyArg_Parser parser = {"O:__call__", kwlist, 0}; + PyObject *obj_self; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, PyVectorcall_NARGS(nargs), kwnames, &parser, &obj_self)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_self; + if (likely(PyObject_TypeCheck(obj_self, CPyType_main___HexBytes))) + arg_self = obj_self; + else { + CPy_TypeError("faster_hexbytes.main.HexBytes", obj_self); + goto fail; + } + PyObject *retval = CPyDef_main___to_0x_hex_HexBytes_obj_____call__(arg___mypyc_self__, arg_self); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "to_0x_hex", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + return NULL; +} + +PyObject *CPyDef_main_____reduce___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner) { + PyObject *cpy_r_r0; + char cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + cpy_r_r0 = (PyObject *)&_Py_NoneStruct; + cpy_r_r1 = cpy_r_instance == cpy_r_r0; + if (!cpy_r_r1) goto CPyL2; + CPy_INCREF(cpy_r___mypyc_self__); + return cpy_r___mypyc_self__; +CPyL2: ; + cpy_r_r2 = PyMethod_New(cpy_r___mypyc_self__, cpy_r_instance); + if (cpy_r_r2 == NULL) goto CPyL4; + return cpy_r_r2; +CPyL4: ; + cpy_r_r3 = NULL; + return cpy_r_r3; +} + +PyObject *CPyPy_main_____reduce___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"instance", "owner", 0}; + static CPyArg_Parser parser = {"OO:__get__", kwlist, 0}; + PyObject *obj_instance; + PyObject *obj_owner; + if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_instance, &obj_owner)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_instance = obj_instance; + PyObject *arg_owner = obj_owner; + PyObject *retval = CPyDef_main_____reduce___3_HexBytes_obj_____get__(arg___mypyc_self__, arg_instance, arg_owner); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__get__", -1, CPyStatic_main___globals); + return NULL; +} + +tuple_T2OT2OO CPyDef_main_____reduce___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self) { + PyObject *cpy_r_r0; + char cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + PyObject **cpy_r_r5; + PyObject *cpy_r_r6; + PyObject *cpy_r_r7; + tuple_T2OO cpy_r_r8; + tuple_T2OT2OO cpy_r_r9; + tuple_T2OT2OO cpy_r_r10; + cpy_r_r0 = CPyStatic_main____bytes_new; + if (likely(cpy_r_r0 != NULL)) goto CPyL3; + PyErr_SetString(PyExc_NameError, "value for final name \"_bytes_new\" was not set"); + cpy_r_r1 = 0; + if (unlikely(!cpy_r_r1)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL6; + } + CPy_Unreachable(); +CPyL3: ; + cpy_r_r2 = CPy_TYPE(cpy_r_self); + cpy_r_r3 = (PyObject *)&PyBytes_Type; + PyObject *cpy_r_r4[1] = {cpy_r_self}; + cpy_r_r5 = (PyObject **)&cpy_r_r4; + cpy_r_r6 = PyObject_Vectorcall(cpy_r_r3, cpy_r_r5, 1, 0); + if (unlikely(cpy_r_r6 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL7; + } + if (likely(PyBytes_Check(cpy_r_r6) || PyByteArray_Check(cpy_r_r6))) + cpy_r_r7 = cpy_r_r6; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__reduce__", 90, CPyStatic_main___globals, "bytes", cpy_r_r6); + goto CPyL7; + } + cpy_r_r8.f0 = cpy_r_r2; + cpy_r_r8.f1 = cpy_r_r7; + CPy_INCREF(cpy_r_r0); + cpy_r_r9.f0 = cpy_r_r0; + cpy_r_r9.f1 = cpy_r_r8; + return cpy_r_r9; +CPyL6: ; + tuple_T2OT2OO __tmp6 = { NULL, (tuple_T2OO) { NULL, NULL } }; + cpy_r_r10 = __tmp6; + return cpy_r_r10; +CPyL7: ; + CPy_DecRef(cpy_r_r2); + goto CPyL6; +} + +PyObject *CPyPy_main_____reduce___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"self", 0}; + static CPyArg_Parser parser = {"O:__call__", kwlist, 0}; + PyObject *obj_self; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, PyVectorcall_NARGS(nargs), kwnames, &parser, &obj_self)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_self; + if (likely(PyObject_TypeCheck(obj_self, CPyType_main___HexBytes))) + arg_self = obj_self; + else { + CPy_TypeError("faster_hexbytes.main.HexBytes", obj_self); + goto fail; + } + tuple_T2OT2OO retval = CPyDef_main_____reduce___3_HexBytes_obj_____call__(arg___mypyc_self__, arg_self); + if (retval.f0 == NULL) { + return NULL; + } + PyObject *retbox = PyTuple_New(2); + if (unlikely(retbox == NULL)) + CPyError_OutOfMemory(); + PyObject *__tmp7 = retval.f0; + PyTuple_SET_ITEM(retbox, 0, __tmp7); + PyObject *__tmp8 = PyTuple_New(2); + if (unlikely(__tmp8 == NULL)) + CPyError_OutOfMemory(); + PyObject *__tmp9 = retval.f1.f0; + PyTuple_SET_ITEM(__tmp8, 0, __tmp9); + PyObject *__tmp10 = retval.f1.f1; + PyTuple_SET_ITEM(__tmp8, 1, __tmp10); + PyTuple_SET_ITEM(retbox, 1, __tmp8); + return retbox; +fail: ; + CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + return NULL; +} + +char CPyDef_main_____top_level__(void) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + char cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + PyObject *cpy_r_r5; + PyObject *cpy_r_r6; + PyObject *cpy_r_r7; + PyObject *cpy_r_r8; + PyObject **cpy_r_r9; + void *cpy_r_r11; + void *cpy_r_r13; + PyObject *cpy_r_r14; + PyObject *cpy_r_r15; + PyObject *cpy_r_r16; + PyObject *cpy_r_r17; + char cpy_r_r18; + PyObject *cpy_r_r19; + PyObject *cpy_r_r20; + PyObject *cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + PyObject *cpy_r_r24; + PyObject *cpy_r_r25; + PyObject *cpy_r_r26; + PyObject *cpy_r_r27; + PyObject *cpy_r_r28; + PyObject *cpy_r_r29; + PyObject *cpy_r_r30; + PyObject *cpy_r_r31; + PyObject *cpy_r_r32; + PyObject *cpy_r_r33; + PyObject *cpy_r_r34; + PyObject *cpy_r_r35; + PyObject *cpy_r_r36; + PyObject *cpy_r_r37; + PyObject *cpy_r_r38; + PyObject *cpy_r_r39; + PyObject *cpy_r_r40; + PyObject *cpy_r_r41; + PyObject *cpy_r_r42; + PyObject *cpy_r_r43; + tuple_T6OOOOOO cpy_r_r44; + PyObject *cpy_r_r45; + PyObject *cpy_r_r46; + PyObject *cpy_r_r47; + PyObject *cpy_r_r48; + int32_t cpy_r_r49; + char cpy_r_r50; + PyObject *cpy_r_r51; + PyObject *cpy_r_r52; + PyObject *cpy_r_r53; + PyObject *cpy_r_r54; + PyObject *cpy_r_r55; + int32_t cpy_r_r56; + char cpy_r_r57; + PyObject *cpy_r_r58; + PyObject *cpy_r_r59; + PyObject *cpy_r_r60; + PyObject *cpy_r_r61; + PyObject *cpy_r_r62; + PyObject *cpy_r_r63; + PyObject *cpy_r_r64; + char cpy_r_r65; + PyObject *cpy_r_r66; + PyObject *cpy_r_r67; + PyObject *cpy_r_r68; + PyObject **cpy_r_r70; + PyObject *cpy_r_r71; + PyObject *cpy_r_r72; + PyObject *cpy_r_r73; + PyObject *cpy_r_r74; + PyObject *cpy_r_r75; + PyObject *cpy_r_r76; + PyObject *cpy_r_r77; + PyObject *cpy_r_r78; + PyObject *cpy_r_r79; + PyObject **cpy_r_r81; + PyObject *cpy_r_r82; + PyObject *cpy_r_r83; + int32_t cpy_r_r84; + char cpy_r_r85; + PyObject *cpy_r_r86; + PyObject *cpy_r_r87; + int32_t cpy_r_r88; + char cpy_r_r89; + PyObject *cpy_r_r90; + PyObject *cpy_r_r91; + int32_t cpy_r_r92; + char cpy_r_r93; + PyObject *cpy_r_r94; + PyObject *cpy_r_r95; + int32_t cpy_r_r96; + char cpy_r_r97; + PyObject *cpy_r_r98; + PyObject *cpy_r_r99; + int32_t cpy_r_r100; + char cpy_r_r101; + PyObject *cpy_r_r102; + PyObject *cpy_r_r103; + int32_t cpy_r_r104; + char cpy_r_r105; + PyObject *cpy_r_r106; + PyObject *cpy_r_r107; + int32_t cpy_r_r108; + char cpy_r_r109; + PyObject *cpy_r_r110; + PyObject *cpy_r_r111; + int32_t cpy_r_r112; + char cpy_r_r113; + PyObject **cpy_r_r115; + PyObject *cpy_r_r116; + PyObject *cpy_r_r117; + PyObject *cpy_r_r118; + PyObject *cpy_r_r119; + PyObject *cpy_r_r120; + PyObject *cpy_r_r121; + PyObject **cpy_r_r123; + PyObject *cpy_r_r124; + PyObject *cpy_r_r125; + PyObject **cpy_r_r127; + PyObject *cpy_r_r128; + PyObject *cpy_r_r129; + PyObject *cpy_r_r130; + int32_t cpy_r_r131; + char cpy_r_r132; + PyObject *cpy_r_r133; + PyObject *cpy_r_r134; + PyObject *cpy_r_r135; + PyObject *cpy_r_r136; + PyObject *cpy_r_r137; + PyObject *cpy_r_r138; + PyObject *cpy_r_r139; + PyObject *cpy_r_r140; + char cpy_r_r141; + PyObject *cpy_r_r142; + PyObject *cpy_r_r143; + PyObject *cpy_r_r144; + PyObject **cpy_r_r146; + PyObject *cpy_r_r147; + PyObject *cpy_r_r148; + PyObject *cpy_r_r149; + PyObject *cpy_r_r150; + PyObject *cpy_r_r151; + PyObject *cpy_r_r152; + PyObject *cpy_r_r153; + int32_t cpy_r_r154; + char cpy_r_r155; + PyObject *cpy_r_r156; + PyObject *cpy_r_r157; + int32_t cpy_r_r158; + char cpy_r_r159; + PyObject *cpy_r_r160; + PyObject *cpy_r_r161; + int32_t cpy_r_r162; + char cpy_r_r163; + PyObject **cpy_r_r165; + PyObject *cpy_r_r166; + PyObject *cpy_r_r167; + PyObject *cpy_r_r168; + PyObject *cpy_r_r169; + PyObject *cpy_r_r170; + PyObject **cpy_r_r172; + PyObject *cpy_r_r173; + PyObject *cpy_r_r174; + PyObject **cpy_r_r176; + PyObject *cpy_r_r177; + PyObject *cpy_r_r178; + PyObject *cpy_r_r179; + int32_t cpy_r_r180; + char cpy_r_r181; + PyObject *cpy_r_r182; + PyObject *cpy_r_r183; + PyObject *cpy_r_r184; + PyObject *cpy_r_r185; + PyObject *cpy_r_r186; + PyObject *cpy_r_r187; + PyObject *cpy_r_r188; + PyObject *cpy_r_r189; + char cpy_r_r190; + PyObject *cpy_r_r191; + PyObject *cpy_r_r192; + PyObject *cpy_r_r193; + PyObject **cpy_r_r195; + PyObject *cpy_r_r196; + PyObject *cpy_r_r197; + PyObject *cpy_r_r198; + PyObject *cpy_r_r199; + PyObject *cpy_r_r200; + PyObject *cpy_r_r201; + PyObject *cpy_r_r202; + int32_t cpy_r_r203; + char cpy_r_r204; + PyObject *cpy_r_r205; + PyObject *cpy_r_r206; + int32_t cpy_r_r207; + char cpy_r_r208; + PyObject *cpy_r_r209; + PyObject *cpy_r_r210; + int32_t cpy_r_r211; + char cpy_r_r212; + PyObject **cpy_r_r214; + PyObject *cpy_r_r215; + PyObject *cpy_r_r216; + PyObject *cpy_r_r217; + PyObject *cpy_r_r218; + PyObject *cpy_r_r219; + PyObject **cpy_r_r221; + PyObject *cpy_r_r222; + PyObject *cpy_r_r223; + PyObject **cpy_r_r225; + PyObject *cpy_r_r226; + PyObject *cpy_r_r227; + PyObject *cpy_r_r228; + int32_t cpy_r_r229; + char cpy_r_r230; + PyObject *cpy_r_r231; + PyObject *cpy_r_r232; + PyObject *cpy_r_r233; + PyObject *cpy_r_r234; + PyObject *cpy_r_r235; + PyObject *cpy_r_r236; + PyObject *cpy_r_r237; + PyObject *cpy_r_r238; + char cpy_r_r239; + PyObject *cpy_r_r240; + PyObject *cpy_r_r241; + PyObject *cpy_r_r242; + PyObject **cpy_r_r244; + PyObject *cpy_r_r245; + PyObject *cpy_r_r246; + PyObject *cpy_r_r247; + PyObject *cpy_r_r248; + PyObject *cpy_r_r249; + PyObject *cpy_r_r250; + PyObject *cpy_r_r251; + int32_t cpy_r_r252; + char cpy_r_r253; + PyObject *cpy_r_r254; + PyObject *cpy_r_r255; + int32_t cpy_r_r256; + char cpy_r_r257; + PyObject *cpy_r_r258; + PyObject *cpy_r_r259; + int32_t cpy_r_r260; + char cpy_r_r261; + PyObject **cpy_r_r263; + PyObject *cpy_r_r264; + PyObject *cpy_r_r265; + PyObject *cpy_r_r266; + PyObject *cpy_r_r267; + PyObject *cpy_r_r268; + PyObject **cpy_r_r270; + PyObject *cpy_r_r271; + PyObject *cpy_r_r272; + PyObject **cpy_r_r274; + PyObject *cpy_r_r275; + PyObject *cpy_r_r276; + PyObject *cpy_r_r277; + int32_t cpy_r_r278; + char cpy_r_r279; + PyObject *cpy_r_r280; + char cpy_r_r281; + cpy_r_r0 = CPyModule_builtins; + cpy_r_r1 = (PyObject *)&_Py_NoneStruct; + cpy_r_r2 = cpy_r_r0 != cpy_r_r1; + if (cpy_r_r2) goto CPyL3; + cpy_r_r3 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'builtins' */ + cpy_r_r4 = PyImport_Import(cpy_r_r3); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", -1, CPyStatic_main___globals); + goto CPyL105; + } + CPyModule_builtins = cpy_r_r4; + CPy_INCREF(CPyModule_builtins); + CPy_DECREF(cpy_r_r4); +CPyL3: ; + cpy_r_r5 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('TYPE_CHECKING', 'Callable', 'Final', 'Tuple', 'Type', + 'Union', 'overload') */ + cpy_r_r6 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'typing' */ + cpy_r_r7 = CPyStatic_main___globals; + cpy_r_r8 = CPyImport_ImportFromMany(cpy_r_r6, cpy_r_r5, cpy_r_r5, cpy_r_r7); + if (unlikely(cpy_r_r8 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + CPyModule_typing = cpy_r_r8; + CPy_INCREF(CPyModule_typing); + CPy_DECREF(cpy_r_r8); + cpy_r_r9 = (PyObject **)&CPyModule_hexbytes___main; + PyObject **cpy_r_r10[1] = {cpy_r_r9}; + cpy_r_r11 = (void *)&cpy_r_r10; + int64_t cpy_r_r12[1] = {14}; + cpy_r_r13 = (void *)&cpy_r_r12; + cpy_r_r14 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* (('hexbytes.main', 'hexbytes.main', 'hexbytes'),) */ + cpy_r_r15 = CPyStatic_main___globals; + cpy_r_r16 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes/main.py' */ + cpy_r_r17 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ + cpy_r_r18 = CPyImport_ImportMany(cpy_r_r14, cpy_r_r11, cpy_r_r15, cpy_r_r16, cpy_r_r17, cpy_r_r13); + if (!cpy_r_r18) goto CPyL105; + cpy_r_r19 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('mypyc_attr',) */ + cpy_r_r20 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypy_extensions' */ + cpy_r_r21 = CPyStatic_main___globals; + cpy_r_r22 = CPyImport_ImportFromMany(cpy_r_r20, cpy_r_r19, cpy_r_r19, cpy_r_r21); + if (unlikely(cpy_r_r22 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + CPyModule_mypy_extensions = cpy_r_r22; + CPy_INCREF(CPyModule_mypy_extensions); + CPy_DECREF(cpy_r_r22); + cpy_r_r23 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('Self',) */ + cpy_r_r24 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'typing_extensions' */ + cpy_r_r25 = CPyStatic_main___globals; + cpy_r_r26 = CPyImport_ImportFromMany(cpy_r_r24, cpy_r_r23, cpy_r_r23, cpy_r_r25); + if (unlikely(cpy_r_r26 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + CPyModule_typing_extensions = cpy_r_r26; + CPy_INCREF(CPyModule_typing_extensions); + CPy_DECREF(cpy_r_r26); + cpy_r_r27 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('to_bytes',) */ + cpy_r_r28 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes._utils' */ + cpy_r_r29 = CPyStatic_main___globals; + cpy_r_r30 = CPyImport_ImportFromMany(cpy_r_r28, cpy_r_r27, cpy_r_r27, cpy_r_r29); + if (unlikely(cpy_r_r30 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + CPyModule_faster_hexbytes____utils = cpy_r_r30; + CPy_INCREF(CPyModule_faster_hexbytes____utils); + CPy_DECREF(cpy_r_r30); + cpy_r_r31 = CPyStatic_main___globals; + cpy_r_r32 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'Union' */ + cpy_r_r33 = CPyDict_GetItem(cpy_r_r31, cpy_r_r32); + if (unlikely(cpy_r_r33 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r34 = (PyObject *)&PyBytes_Type; + cpy_r_r35 = (PyObject *)&PyUnicode_Type; + cpy_r_r36 = (PyObject *)&PyBool_Type; + cpy_r_r37 = CPyModule_builtins; + cpy_r_r38 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'bytearray' */ + cpy_r_r39 = CPyObject_GetAttr(cpy_r_r37, cpy_r_r38); + if (unlikely(cpy_r_r39 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL106; + } + cpy_r_r40 = (PyObject *)&PyLong_Type; + cpy_r_r41 = CPyModule_builtins; + cpy_r_r42 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'memoryview' */ + cpy_r_r43 = CPyObject_GetAttr(cpy_r_r41, cpy_r_r42); + if (unlikely(cpy_r_r43 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL107; + } + CPy_INCREF(cpy_r_r34); + CPy_INCREF(cpy_r_r35); + CPy_INCREF(cpy_r_r36); + CPy_INCREF(cpy_r_r40); + cpy_r_r44.f0 = cpy_r_r34; + cpy_r_r44.f1 = cpy_r_r35; + cpy_r_r44.f2 = cpy_r_r36; + cpy_r_r44.f3 = cpy_r_r39; + cpy_r_r44.f4 = cpy_r_r40; + cpy_r_r44.f5 = cpy_r_r43; + cpy_r_r45 = PyTuple_New(6); + if (unlikely(cpy_r_r45 == NULL)) + CPyError_OutOfMemory(); + PyObject *__tmp11 = cpy_r_r44.f0; + PyTuple_SET_ITEM(cpy_r_r45, 0, __tmp11); + PyObject *__tmp12 = cpy_r_r44.f1; + PyTuple_SET_ITEM(cpy_r_r45, 1, __tmp12); + PyObject *__tmp13 = cpy_r_r44.f2; + PyTuple_SET_ITEM(cpy_r_r45, 2, __tmp13); + PyObject *__tmp14 = cpy_r_r44.f3; + PyTuple_SET_ITEM(cpy_r_r45, 3, __tmp14); + PyObject *__tmp15 = cpy_r_r44.f4; + PyTuple_SET_ITEM(cpy_r_r45, 4, __tmp15); + PyObject *__tmp16 = cpy_r_r44.f5; + PyTuple_SET_ITEM(cpy_r_r45, 5, __tmp16); + cpy_r_r46 = PyObject_GetItem(cpy_r_r33, cpy_r_r45); + CPy_DECREF(cpy_r_r33); + CPy_DECREF(cpy_r_r45); + if (unlikely(cpy_r_r46 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r47 = CPyStatic_main___globals; + cpy_r_r48 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'BytesLike' */ + cpy_r_r49 = CPyDict_SetItem(cpy_r_r47, cpy_r_r48, cpy_r_r46); + CPy_DECREF(cpy_r_r46); + cpy_r_r50 = cpy_r_r49 >= 0; + if (unlikely(!cpy_r_r50)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r51 = (PyObject *)&PyBytes_Type; + cpy_r_r52 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__new__' */ + cpy_r_r53 = CPyObject_GetAttr(cpy_r_r51, cpy_r_r52); + if (unlikely(cpy_r_r53 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + CPyStatic_main____bytes_new = cpy_r_r53; + CPy_INCREF(CPyStatic_main____bytes_new); + cpy_r_r54 = CPyStatic_main___globals; + cpy_r_r55 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_bytes_new' */ + cpy_r_r56 = CPyDict_SetItem(cpy_r_r54, cpy_r_r55, cpy_r_r53); + CPy_DECREF(cpy_r_r53); + cpy_r_r57 = cpy_r_r56 >= 0; + if (unlikely(!cpy_r_r57)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r58 = CPyModule_hexbytes___main; + cpy_r_r59 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'HexBytes' */ + cpy_r_r60 = CPyObject_GetAttr(cpy_r_r58, cpy_r_r59); + if (unlikely(cpy_r_r60 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r61 = PyTuple_Pack(1, cpy_r_r60); + CPy_DECREF(cpy_r_r60); + if (unlikely(cpy_r_r61 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r62 = (PyObject *)&PyType_Type; + cpy_r_r63 = CPy_CalculateMetaclass(cpy_r_r62, cpy_r_r61); + if (unlikely(cpy_r_r63 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL108; + } + cpy_r_r64 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__prepare__' */ + cpy_r_r65 = PyObject_HasAttr(cpy_r_r63, cpy_r_r64); + if (!cpy_r_r65) goto CPyL24; + cpy_r_r66 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'HexBytes' */ + cpy_r_r67 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__prepare__' */ + cpy_r_r68 = CPyObject_GetAttr(cpy_r_r63, cpy_r_r67); + if (unlikely(cpy_r_r68 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL108; + } + PyObject *cpy_r_r69[2] = {cpy_r_r66, cpy_r_r61}; + cpy_r_r70 = (PyObject **)&cpy_r_r69; + cpy_r_r71 = PyObject_Vectorcall(cpy_r_r68, cpy_r_r70, 2, 0); + CPy_DECREF(cpy_r_r68); + if (unlikely(cpy_r_r71 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL108; + } + if (likely(PyDict_Check(cpy_r_r71))) + cpy_r_r72 = cpy_r_r71; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "", 38, CPyStatic_main___globals, "dict", cpy_r_r71); + goto CPyL108; + } + cpy_r_r73 = cpy_r_r72; + goto CPyL26; +CPyL24: ; + cpy_r_r74 = PyDict_New(); + if (unlikely(cpy_r_r74 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL108; + } + cpy_r_r73 = cpy_r_r74; +CPyL26: ; + cpy_r_r75 = PyDict_New(); + if (unlikely(cpy_r_r75 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL109; + } + cpy_r_r76 = CPyDef_main_____new___3_HexBytes_obj(); + if (unlikely(cpy_r_r76 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r77 = CPyModule_builtins; + cpy_r_r78 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'staticmethod' */ + cpy_r_r79 = CPyObject_GetAttr(cpy_r_r77, cpy_r_r78); + if (unlikely(cpy_r_r79 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL111; + } + PyObject *cpy_r_r80[1] = {cpy_r_r76}; + cpy_r_r81 = (PyObject **)&cpy_r_r80; + cpy_r_r82 = PyObject_Vectorcall(cpy_r_r79, cpy_r_r81, 1, 0); + CPy_DECREF(cpy_r_r79); + if (unlikely(cpy_r_r82 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL111; + } + CPy_DECREF_NO_IMM(cpy_r_r76); + cpy_r_r83 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__new__' */ + cpy_r_r84 = CPyDict_SetItem(cpy_r_r73, cpy_r_r83, cpy_r_r82); + CPy_DECREF(cpy_r_r82); + cpy_r_r85 = cpy_r_r84 >= 0; + if (unlikely(!cpy_r_r85)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r86 = CPyDef_main_____getitem___3_HexBytes_obj(); + if (unlikely(cpy_r_r86 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r87 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__getitem__' */ + cpy_r_r88 = CPyDict_SetItem(cpy_r_r73, cpy_r_r87, cpy_r_r86); + CPy_DECREF_NO_IMM(cpy_r_r86); + cpy_r_r89 = cpy_r_r88 >= 0; + if (unlikely(!cpy_r_r89)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r90 = CPyDef_main_____repr___3_HexBytes_obj(); + if (unlikely(cpy_r_r90 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r91 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__repr__' */ + cpy_r_r92 = CPyDict_SetItem(cpy_r_r73, cpy_r_r91, cpy_r_r90); + CPy_DECREF_NO_IMM(cpy_r_r90); + cpy_r_r93 = cpy_r_r92 >= 0; + if (unlikely(!cpy_r_r93)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r94 = CPyDef_main___to_0x_hex_HexBytes_obj(); + if (unlikely(cpy_r_r94 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r95 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'to_0x_hex' */ + cpy_r_r96 = CPyDict_SetItem(cpy_r_r73, cpy_r_r95, cpy_r_r94); + CPy_DECREF_NO_IMM(cpy_r_r94); + cpy_r_r97 = cpy_r_r96 >= 0; + if (unlikely(!cpy_r_r97)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r98 = CPyDef_main_____reduce___3_HexBytes_obj(); + if (unlikely(cpy_r_r98 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r99 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__reduce__' */ + cpy_r_r100 = CPyDict_SetItem(cpy_r_r73, cpy_r_r99, cpy_r_r98); + CPy_DECREF_NO_IMM(cpy_r_r98); + cpy_r_r101 = cpy_r_r100 >= 0; + if (unlikely(!cpy_r_r101)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r102 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'HexBytes' */ + cpy_r_r103 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__annotations__' */ + cpy_r_r104 = CPyDict_SetItem(cpy_r_r73, cpy_r_r103, cpy_r_r75); + CPy_DECREF(cpy_r_r75); + cpy_r_r105 = cpy_r_r104 >= 0; + if (unlikely(!cpy_r_r105)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL109; + } + cpy_r_r106 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypyc filler docstring' */ + cpy_r_r107 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__doc__' */ + cpy_r_r108 = CPyDict_SetItem(cpy_r_r73, cpy_r_r107, cpy_r_r106); + cpy_r_r109 = cpy_r_r108 >= 0; + if (unlikely(!cpy_r_r109)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL109; + } + cpy_r_r110 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes.main' */ + cpy_r_r111 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__module__' */ + cpy_r_r112 = CPyDict_SetItem(cpy_r_r73, cpy_r_r111, cpy_r_r110); + cpy_r_r113 = cpy_r_r112 >= 0; + if (unlikely(!cpy_r_r113)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL109; + } + PyObject *cpy_r_r114[3] = {cpy_r_r102, cpy_r_r61, cpy_r_r73}; + cpy_r_r115 = (PyObject **)&cpy_r_r114; + cpy_r_r116 = PyObject_Vectorcall(cpy_r_r63, cpy_r_r115, 3, 0); + if (unlikely(cpy_r_r116 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL109; + } + CPy_DECREF(cpy_r_r73); + CPy_DECREF(cpy_r_r61); + cpy_r_r117 = CPyStatic_main___globals; + cpy_r_r118 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypyc_attr' */ + cpy_r_r119 = CPyDict_GetItem(cpy_r_r117, cpy_r_r118); + if (unlikely(cpy_r_r119 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL112; + } + cpy_r_r120 = 0 ? Py_True : Py_False; + cpy_r_r121 = 1 ? Py_True : Py_False; + PyObject *cpy_r_r122[2] = {cpy_r_r120, cpy_r_r121}; + cpy_r_r123 = (PyObject **)&cpy_r_r122; + cpy_r_r124 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('native_class', 'allow_interpreted_subclasses') */ + cpy_r_r125 = PyObject_Vectorcall(cpy_r_r119, cpy_r_r123, 0, cpy_r_r124); + CPy_DECREF(cpy_r_r119); + if (unlikely(cpy_r_r125 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL112; + } + PyObject *cpy_r_r126[1] = {cpy_r_r116}; + cpy_r_r127 = (PyObject **)&cpy_r_r126; + cpy_r_r128 = PyObject_Vectorcall(cpy_r_r125, cpy_r_r127, 1, 0); + CPy_DECREF(cpy_r_r125); + if (unlikely(cpy_r_r128 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL112; + } + CPy_DECREF(cpy_r_r116); + CPyType_main___HexBytes = (PyTypeObject *)cpy_r_r128; + CPy_INCREF(CPyType_main___HexBytes); + cpy_r_r129 = CPyStatic_main___globals; + cpy_r_r130 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'HexBytes' */ + cpy_r_r131 = PyDict_SetItem(cpy_r_r129, cpy_r_r130, cpy_r_r128); + CPy_DECREF(cpy_r_r128); + cpy_r_r132 = cpy_r_r131 >= 0; + if (unlikely(!cpy_r_r132)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r133 = (PyObject *)CPyType_main___HexBytes; + cpy_r_r134 = CPyStatic_main___globals; + cpy_r_r135 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'HexBytes' */ + cpy_r_r136 = CPyDict_GetItem(cpy_r_r134, cpy_r_r135); + if (unlikely(cpy_r_r136 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r137 = PyTuple_Pack(1, cpy_r_r136); + CPy_DECREF(cpy_r_r136); + if (unlikely(cpy_r_r137 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r138 = (PyObject *)&PyType_Type; + cpy_r_r139 = CPy_CalculateMetaclass(cpy_r_r138, cpy_r_r137); + if (unlikely(cpy_r_r139 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL113; + } + cpy_r_r140 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__prepare__' */ + cpy_r_r141 = PyObject_HasAttr(cpy_r_r139, cpy_r_r140); + if (!cpy_r_r141) goto CPyL55; + cpy_r_r142 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass1' */ + cpy_r_r143 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__prepare__' */ + cpy_r_r144 = CPyObject_GetAttr(cpy_r_r139, cpy_r_r143); + if (unlikely(cpy_r_r144 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL113; + } + PyObject *cpy_r_r145[2] = {cpy_r_r142, cpy_r_r137}; + cpy_r_r146 = (PyObject **)&cpy_r_r145; + cpy_r_r147 = PyObject_Vectorcall(cpy_r_r144, cpy_r_r146, 2, 0); + CPy_DECREF(cpy_r_r144); + if (unlikely(cpy_r_r147 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL113; + } + if (likely(PyDict_Check(cpy_r_r147))) + cpy_r_r148 = cpy_r_r147; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "", 97, CPyStatic_main___globals, "dict", cpy_r_r147); + goto CPyL113; + } + cpy_r_r149 = cpy_r_r148; + goto CPyL57; +CPyL55: ; + cpy_r_r150 = PyDict_New(); + if (unlikely(cpy_r_r150 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL113; + } + cpy_r_r149 = cpy_r_r150; +CPyL57: ; + cpy_r_r151 = PyDict_New(); + if (unlikely(cpy_r_r151 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL114; + } + cpy_r_r152 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass1' */ + cpy_r_r153 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__annotations__' */ + cpy_r_r154 = CPyDict_SetItem(cpy_r_r149, cpy_r_r153, cpy_r_r151); + CPy_DECREF(cpy_r_r151); + cpy_r_r155 = cpy_r_r154 >= 0; + if (unlikely(!cpy_r_r155)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL114; + } + cpy_r_r156 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypyc filler docstring' */ + cpy_r_r157 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__doc__' */ + cpy_r_r158 = CPyDict_SetItem(cpy_r_r149, cpy_r_r157, cpy_r_r156); + cpy_r_r159 = cpy_r_r158 >= 0; + if (unlikely(!cpy_r_r159)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL114; + } + cpy_r_r160 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes.main' */ + cpy_r_r161 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__module__' */ + cpy_r_r162 = CPyDict_SetItem(cpy_r_r149, cpy_r_r161, cpy_r_r160); + cpy_r_r163 = cpy_r_r162 >= 0; + if (unlikely(!cpy_r_r163)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL114; + } + PyObject *cpy_r_r164[3] = {cpy_r_r152, cpy_r_r137, cpy_r_r149}; + cpy_r_r165 = (PyObject **)&cpy_r_r164; + cpy_r_r166 = PyObject_Vectorcall(cpy_r_r139, cpy_r_r165, 3, 0); + if (unlikely(cpy_r_r166 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL114; + } + CPy_DECREF(cpy_r_r149); + CPy_DECREF(cpy_r_r137); + cpy_r_r167 = CPyStatic_main___globals; + cpy_r_r168 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypyc_attr' */ + cpy_r_r169 = CPyDict_GetItem(cpy_r_r167, cpy_r_r168); + if (unlikely(cpy_r_r169 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL115; + } + cpy_r_r170 = 0 ? Py_True : Py_False; + PyObject *cpy_r_r171[1] = {cpy_r_r170}; + cpy_r_r172 = (PyObject **)&cpy_r_r171; + cpy_r_r173 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('native_class',) */ + cpy_r_r174 = PyObject_Vectorcall(cpy_r_r169, cpy_r_r172, 0, cpy_r_r173); + CPy_DECREF(cpy_r_r169); + if (unlikely(cpy_r_r174 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL115; + } + PyObject *cpy_r_r175[1] = {cpy_r_r166}; + cpy_r_r176 = (PyObject **)&cpy_r_r175; + cpy_r_r177 = PyObject_Vectorcall(cpy_r_r174, cpy_r_r176, 1, 0); + CPy_DECREF(cpy_r_r174); + if (unlikely(cpy_r_r177 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL115; + } + CPy_DECREF(cpy_r_r166); + CPyType_main____HexBytesSubclass1 = (PyTypeObject *)cpy_r_r177; + CPy_INCREF(CPyType_main____HexBytesSubclass1); + cpy_r_r178 = CPyStatic_main___globals; + cpy_r_r179 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass1' */ + cpy_r_r180 = PyDict_SetItem(cpy_r_r178, cpy_r_r179, cpy_r_r177); + CPy_DECREF(cpy_r_r177); + cpy_r_r181 = cpy_r_r180 >= 0; + if (unlikely(!cpy_r_r181)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r182 = (PyObject *)CPyType_main____HexBytesSubclass1; + cpy_r_r183 = CPyStatic_main___globals; + cpy_r_r184 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'HexBytes' */ + cpy_r_r185 = CPyDict_GetItem(cpy_r_r183, cpy_r_r184); + if (unlikely(cpy_r_r185 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r186 = PyTuple_Pack(1, cpy_r_r185); + CPy_DECREF(cpy_r_r185); + if (unlikely(cpy_r_r186 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r187 = (PyObject *)&PyType_Type; + cpy_r_r188 = CPy_CalculateMetaclass(cpy_r_r187, cpy_r_r186); + if (unlikely(cpy_r_r188 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL116; + } + cpy_r_r189 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__prepare__' */ + cpy_r_r190 = PyObject_HasAttr(cpy_r_r188, cpy_r_r189); + if (!cpy_r_r190) goto CPyL74; + cpy_r_r191 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass2' */ + cpy_r_r192 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__prepare__' */ + cpy_r_r193 = CPyObject_GetAttr(cpy_r_r188, cpy_r_r192); + if (unlikely(cpy_r_r193 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL116; + } + PyObject *cpy_r_r194[2] = {cpy_r_r191, cpy_r_r186}; + cpy_r_r195 = (PyObject **)&cpy_r_r194; + cpy_r_r196 = PyObject_Vectorcall(cpy_r_r193, cpy_r_r195, 2, 0); + CPy_DECREF(cpy_r_r193); + if (unlikely(cpy_r_r196 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL116; + } + if (likely(PyDict_Check(cpy_r_r196))) + cpy_r_r197 = cpy_r_r196; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "", 99, CPyStatic_main___globals, "dict", cpy_r_r196); + goto CPyL116; + } + cpy_r_r198 = cpy_r_r197; + goto CPyL76; +CPyL74: ; + cpy_r_r199 = PyDict_New(); + if (unlikely(cpy_r_r199 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL116; + } + cpy_r_r198 = cpy_r_r199; +CPyL76: ; + cpy_r_r200 = PyDict_New(); + if (unlikely(cpy_r_r200 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL117; + } + cpy_r_r201 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass2' */ + cpy_r_r202 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__annotations__' */ + cpy_r_r203 = CPyDict_SetItem(cpy_r_r198, cpy_r_r202, cpy_r_r200); + CPy_DECREF(cpy_r_r200); + cpy_r_r204 = cpy_r_r203 >= 0; + if (unlikely(!cpy_r_r204)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL117; + } + cpy_r_r205 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypyc filler docstring' */ + cpy_r_r206 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__doc__' */ + cpy_r_r207 = CPyDict_SetItem(cpy_r_r198, cpy_r_r206, cpy_r_r205); + cpy_r_r208 = cpy_r_r207 >= 0; + if (unlikely(!cpy_r_r208)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL117; + } + cpy_r_r209 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes.main' */ + cpy_r_r210 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__module__' */ + cpy_r_r211 = CPyDict_SetItem(cpy_r_r198, cpy_r_r210, cpy_r_r209); + cpy_r_r212 = cpy_r_r211 >= 0; + if (unlikely(!cpy_r_r212)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL117; + } + PyObject *cpy_r_r213[3] = {cpy_r_r201, cpy_r_r186, cpy_r_r198}; + cpy_r_r214 = (PyObject **)&cpy_r_r213; + cpy_r_r215 = PyObject_Vectorcall(cpy_r_r188, cpy_r_r214, 3, 0); + if (unlikely(cpy_r_r215 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL117; + } + CPy_DECREF(cpy_r_r198); + CPy_DECREF(cpy_r_r186); + cpy_r_r216 = CPyStatic_main___globals; + cpy_r_r217 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypyc_attr' */ + cpy_r_r218 = CPyDict_GetItem(cpy_r_r216, cpy_r_r217); + if (unlikely(cpy_r_r218 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL118; + } + cpy_r_r219 = 0 ? Py_True : Py_False; + PyObject *cpy_r_r220[1] = {cpy_r_r219}; + cpy_r_r221 = (PyObject **)&cpy_r_r220; + cpy_r_r222 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('native_class',) */ + cpy_r_r223 = PyObject_Vectorcall(cpy_r_r218, cpy_r_r221, 0, cpy_r_r222); + CPy_DECREF(cpy_r_r218); + if (unlikely(cpy_r_r223 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL118; + } + PyObject *cpy_r_r224[1] = {cpy_r_r215}; + cpy_r_r225 = (PyObject **)&cpy_r_r224; + cpy_r_r226 = PyObject_Vectorcall(cpy_r_r223, cpy_r_r225, 1, 0); + CPy_DECREF(cpy_r_r223); + if (unlikely(cpy_r_r226 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL118; + } + CPy_DECREF(cpy_r_r215); + CPyType_main____HexBytesSubclass2 = (PyTypeObject *)cpy_r_r226; + CPy_INCREF(CPyType_main____HexBytesSubclass2); + cpy_r_r227 = CPyStatic_main___globals; + cpy_r_r228 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass2' */ + cpy_r_r229 = PyDict_SetItem(cpy_r_r227, cpy_r_r228, cpy_r_r226); + CPy_DECREF(cpy_r_r226); + cpy_r_r230 = cpy_r_r229 >= 0; + if (unlikely(!cpy_r_r230)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r231 = (PyObject *)CPyType_main____HexBytesSubclass2; + cpy_r_r232 = CPyStatic_main___globals; + cpy_r_r233 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'HexBytes' */ + cpy_r_r234 = CPyDict_GetItem(cpy_r_r232, cpy_r_r233); + if (unlikely(cpy_r_r234 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r235 = PyTuple_Pack(1, cpy_r_r234); + CPy_DECREF(cpy_r_r234); + if (unlikely(cpy_r_r235 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r236 = (PyObject *)&PyType_Type; + cpy_r_r237 = CPy_CalculateMetaclass(cpy_r_r236, cpy_r_r235); + if (unlikely(cpy_r_r237 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL119; + } + cpy_r_r238 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__prepare__' */ + cpy_r_r239 = PyObject_HasAttr(cpy_r_r237, cpy_r_r238); + if (!cpy_r_r239) goto CPyL93; + cpy_r_r240 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass3' */ + cpy_r_r241 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__prepare__' */ + cpy_r_r242 = CPyObject_GetAttr(cpy_r_r237, cpy_r_r241); + if (unlikely(cpy_r_r242 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL119; + } + PyObject *cpy_r_r243[2] = {cpy_r_r240, cpy_r_r235}; + cpy_r_r244 = (PyObject **)&cpy_r_r243; + cpy_r_r245 = PyObject_Vectorcall(cpy_r_r242, cpy_r_r244, 2, 0); + CPy_DECREF(cpy_r_r242); + if (unlikely(cpy_r_r245 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL119; + } + if (likely(PyDict_Check(cpy_r_r245))) + cpy_r_r246 = cpy_r_r245; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "", 101, CPyStatic_main___globals, "dict", cpy_r_r245); + goto CPyL119; + } + cpy_r_r247 = cpy_r_r246; + goto CPyL95; +CPyL93: ; + cpy_r_r248 = PyDict_New(); + if (unlikely(cpy_r_r248 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL119; + } + cpy_r_r247 = cpy_r_r248; +CPyL95: ; + cpy_r_r249 = PyDict_New(); + if (unlikely(cpy_r_r249 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL120; + } + cpy_r_r250 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass3' */ + cpy_r_r251 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__annotations__' */ + cpy_r_r252 = CPyDict_SetItem(cpy_r_r247, cpy_r_r251, cpy_r_r249); + CPy_DECREF(cpy_r_r249); + cpy_r_r253 = cpy_r_r252 >= 0; + if (unlikely(!cpy_r_r253)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL120; + } + cpy_r_r254 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypyc filler docstring' */ + cpy_r_r255 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__doc__' */ + cpy_r_r256 = CPyDict_SetItem(cpy_r_r247, cpy_r_r255, cpy_r_r254); + cpy_r_r257 = cpy_r_r256 >= 0; + if (unlikely(!cpy_r_r257)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL120; + } + cpy_r_r258 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes.main' */ + cpy_r_r259 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__module__' */ + cpy_r_r260 = CPyDict_SetItem(cpy_r_r247, cpy_r_r259, cpy_r_r258); + cpy_r_r261 = cpy_r_r260 >= 0; + if (unlikely(!cpy_r_r261)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL120; + } + PyObject *cpy_r_r262[3] = {cpy_r_r250, cpy_r_r235, cpy_r_r247}; + cpy_r_r263 = (PyObject **)&cpy_r_r262; + cpy_r_r264 = PyObject_Vectorcall(cpy_r_r237, cpy_r_r263, 3, 0); + if (unlikely(cpy_r_r264 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL120; + } + CPy_DECREF(cpy_r_r247); + CPy_DECREF(cpy_r_r235); + cpy_r_r265 = CPyStatic_main___globals; + cpy_r_r266 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'mypyc_attr' */ + cpy_r_r267 = CPyDict_GetItem(cpy_r_r265, cpy_r_r266); + if (unlikely(cpy_r_r267 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL121; + } + cpy_r_r268 = 0 ? Py_True : Py_False; + PyObject *cpy_r_r269[1] = {cpy_r_r268}; + cpy_r_r270 = (PyObject **)&cpy_r_r269; + cpy_r_r271 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('native_class',) */ + cpy_r_r272 = PyObject_Vectorcall(cpy_r_r267, cpy_r_r270, 0, cpy_r_r271); + CPy_DECREF(cpy_r_r267); + if (unlikely(cpy_r_r272 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL121; + } + PyObject *cpy_r_r273[1] = {cpy_r_r264}; + cpy_r_r274 = (PyObject **)&cpy_r_r273; + cpy_r_r275 = PyObject_Vectorcall(cpy_r_r272, cpy_r_r274, 1, 0); + CPy_DECREF(cpy_r_r272); + if (unlikely(cpy_r_r275 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL121; + } + CPy_DECREF(cpy_r_r264); + CPyType_main____HexBytesSubclass3 = (PyTypeObject *)cpy_r_r275; + CPy_INCREF(CPyType_main____HexBytesSubclass3); + cpy_r_r276 = CPyStatic_main___globals; + cpy_r_r277 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_HexBytesSubclass3' */ + cpy_r_r278 = PyDict_SetItem(cpy_r_r276, cpy_r_r277, cpy_r_r275); + CPy_DECREF(cpy_r_r275); + cpy_r_r279 = cpy_r_r278 >= 0; + if (unlikely(!cpy_r_r279)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r280 = (PyObject *)CPyType_main____HexBytesSubclass3; + return 1; +CPyL105: ; + cpy_r_r281 = 2; + return cpy_r_r281; +CPyL106: ; + CPy_DecRef(cpy_r_r33); + goto CPyL105; +CPyL107: ; + CPy_DecRef(cpy_r_r33); + CPy_DecRef(cpy_r_r39); + goto CPyL105; +CPyL108: ; + CPy_DecRef(cpy_r_r61); + goto CPyL105; +CPyL109: ; + CPy_DecRef(cpy_r_r61); + CPy_DecRef(cpy_r_r73); + goto CPyL105; +CPyL110: ; + CPy_DecRef(cpy_r_r61); + CPy_DecRef(cpy_r_r73); + CPy_DecRef(cpy_r_r75); + goto CPyL105; +CPyL111: ; + CPy_DecRef(cpy_r_r61); + CPy_DecRef(cpy_r_r73); + CPy_DecRef(cpy_r_r75); + CPy_DecRef(cpy_r_r76); + goto CPyL105; +CPyL112: ; + CPy_DecRef(cpy_r_r116); + goto CPyL105; +CPyL113: ; + CPy_DecRef(cpy_r_r137); + goto CPyL105; +CPyL114: ; + CPy_DecRef(cpy_r_r137); + CPy_DecRef(cpy_r_r149); + goto CPyL105; +CPyL115: ; + CPy_DecRef(cpy_r_r166); + goto CPyL105; +CPyL116: ; + CPy_DecRef(cpy_r_r186); + goto CPyL105; +CPyL117: ; + CPy_DecRef(cpy_r_r186); + CPy_DecRef(cpy_r_r198); + goto CPyL105; +CPyL118: ; + CPy_DecRef(cpy_r_r215); + goto CPyL105; +CPyL119: ; + CPy_DecRef(cpy_r_r235); + goto CPyL105; +CPyL120: ; + CPy_DecRef(cpy_r_r235); + CPy_DecRef(cpy_r_r247); + goto CPyL105; +CPyL121: ; + CPy_DecRef(cpy_r_r264); + goto CPyL105; +} + +int CPyGlobalsInit(void) +{ + static int is_initialized = 0; + if (is_initialized) return 0; + + CPy_Init(); + CPyModule_faster_hexbytes = Py_None; + CPyModule_builtins = Py_None; + CPyModule_importlib___metadata = Py_None; + CPyModule_faster_hexbytes___main = Py_None; + CPyModule_faster_hexbytes____utils = Py_None; + CPyModule_builtins = Py_None; + CPyModule_binascii = Py_None; + CPyModule_typing = Py_None; + CPyModule_faster_hexbytes___main = Py_None; + CPyModule_builtins = Py_None; + CPyModule_typing = Py_None; + CPyModule_hexbytes___main = Py_None; + CPyModule_mypy_extensions = Py_None; + CPyModule_typing_extensions = Py_None; + CPyModule_faster_hexbytes____utils = Py_None; + if (CPyStatics_Initialize(CPyStatics, CPyLit_Str, CPyLit_Bytes, CPyLit_Int, CPyLit_Float, CPyLit_Complex, CPyLit_Tuple, CPyLit_FrozenSet) < 0) { + return -1; + } + is_initialized = 1; + return 0; +} + +PyObject *CPyStatics[DIFFCHECK_PLACEHOLDER]; +const char * const CPyLit_Str[] = { + "\005\bbuiltins\aversion\t__version\022importlib.metadata\bHexBytes", + "\004\024faster_hexbytes.main\a__all__\bhexbytes\v__version__", + "\006 Cannot convert negative integer \t to bytes\nValueError\003hex\nmemoryview\000", + "\t\017Cannot convert \a{!r:{}}\006format\t of type \005{:{}}\tTypeError\0020x\0020X\0010", + "\002\022UnicodeDecodeError\vhex string ", + "\002( may only contain [0-9a-fA-F] characters\bbinascii", + "\006\031faster_hexbytes/_utils.py\b\005Final\005Union\006typing\tunhexlify", + "\a\v__getitem__\fHexBytes(\'0x\002\')\rTYPE_CHECKING\bCallable\005Tuple\004Type", + "\004\boverload\rhexbytes.main\027faster_hexbytes/main.py\nmypyc_attr", + "\004\017mypy_extensions\004Self\021typing_extensions\bto_bytes", + "\005\026faster_hexbytes._utils\tbytearray\tBytesLike\a__new__\n_bytes_new", + "\005\v__prepare__\fstaticmethod\b__repr__\tto_0x_hex\n__reduce__", + "\004\017__annotations__\026mypyc filler docstring\a__doc__\n__module__", + "\003\fnative_class\034allow_interpreted_subclasses\022_HexBytesSubclass1", + "\002\022_HexBytesSubclass2\022_HexBytesSubclass3", + "", +}; +const char * const CPyLit_Bytes[] = { + "\002\001\001\001\000", + "", +}; +const char * const CPyLit_Int[] = { + "", +}; +const double CPyLit_Float[] = {0}; +const double CPyLit_Complex[] = {0}; +const int CPyLit_Tuple[] = { + 14, 1, 4, 1, 5, 1, 7, 3, 30, 30, 30, 1, 76, 2, 33, 34, 7, 40, 41, + 33, 42, 43, 34, 44, 3, 45, 45, 10, 1, 80, 1, 47, 1, 49, 1, 51, 2, 66, + 67, 1, 66 +}; +const int CPyLit_FrozenSet[] = {0}; +CPyModule *CPyModule_faster_hexbytes__internal = NULL; +CPyModule *CPyModule_faster_hexbytes; +PyObject *CPyStatic_faster_hexbytes___globals; +CPyModule *CPyModule_builtins; +CPyModule *CPyModule_importlib___metadata; +CPyModule *CPyModule_faster_hexbytes___main__internal = NULL; +CPyModule *CPyModule_faster_hexbytes___main; +CPyModule *CPyModule_faster_hexbytes____utils__internal = NULL; +CPyModule *CPyModule_faster_hexbytes____utils; +PyObject *CPyStatic__utils___globals; +CPyModule *CPyModule_binascii; +CPyModule *CPyModule_typing; +PyObject *CPyStatic_main___globals; +CPyModule *CPyModule_hexbytes___main; +CPyModule *CPyModule_mypy_extensions; +CPyModule *CPyModule_typing_extensions; +char CPyDef_faster_hexbytes_____top_level__(void); +PyObject *CPyStatic__utils___unhexlify = NULL; +PyObject *CPyDef__utils___to_bytes(PyObject *cpy_r_val); +PyObject *CPyPy__utils___to_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef__utils___hexstr_to_bytes(PyObject *cpy_r_hexstr); +PyObject *CPyPy__utils___hexstr_to_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef__utils_____top_level__(void); +PyObject *CPyStatic_main____bytes_new = NULL; +PyTypeObject *CPyType_main___HexBytes; +PyTypeObject *CPyType_main____HexBytesSubclass1; +PyTypeObject *CPyType_main____HexBytesSubclass2; +PyTypeObject *CPyType_main____HexBytesSubclass3; +PyTypeObject *CPyType_main_____new___3_HexBytes_obj; +PyObject *CPyDef_main_____new___3_HexBytes_obj(void); +CPyThreadLocal faster_hexbytes___main_____new___3_HexBytes_objObject *main_____new___3_HexBytes_obj_free_instance; +PyTypeObject *CPyType_main_____getitem___3_HexBytes_obj; +PyObject *CPyDef_main_____getitem___3_HexBytes_obj(void); +CPyThreadLocal faster_hexbytes___main_____getitem___3_HexBytes_objObject *main_____getitem___3_HexBytes_obj_free_instance; +PyTypeObject *CPyType_main_____repr___3_HexBytes_obj; +PyObject *CPyDef_main_____repr___3_HexBytes_obj(void); +CPyThreadLocal faster_hexbytes___main_____repr___3_HexBytes_objObject *main_____repr___3_HexBytes_obj_free_instance; +PyTypeObject *CPyType_main___to_0x_hex_HexBytes_obj; +PyObject *CPyDef_main___to_0x_hex_HexBytes_obj(void); +CPyThreadLocal faster_hexbytes___main___to_0x_hex_HexBytes_objObject *main___to_0x_hex_HexBytes_obj_free_instance; +PyTypeObject *CPyType_main_____reduce___3_HexBytes_obj; +PyObject *CPyDef_main_____reduce___3_HexBytes_obj(void); +CPyThreadLocal faster_hexbytes___main_____reduce___3_HexBytes_objObject *main_____reduce___3_HexBytes_obj_free_instance; +PyObject *CPyDef_main_____new___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +PyObject *CPyPy_main_____new___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_main_____new___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_val); +PyObject *CPyPy_main_____new___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_main_____getitem___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +PyObject *CPyPy_main_____getitem___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_main_____getitem___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self, PyObject *cpy_r_key); +PyObject *CPyPy_main_____getitem___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_main_____repr___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +PyObject *CPyPy_main_____repr___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_main_____repr___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self); +PyObject *CPyPy_main_____repr___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_main___to_0x_hex_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +PyObject *CPyPy_main___to_0x_hex_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_main___to_0x_hex_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self); +PyObject *CPyPy_main___to_0x_hex_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_main_____reduce___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +PyObject *CPyPy_main_____reduce___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +tuple_T2OT2OO CPyDef_main_____reduce___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self); +PyObject *CPyPy_main_____reduce___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_main_____top_level__(void); + +static int exec_6a32f4913d613d6a7ddf__mypyc(PyObject *module) +{ + int res; + PyObject *capsule; + PyObject *tmp; + + extern PyObject *CPyInit_faster_hexbytes(void); + capsule = PyCapsule_New((void *)CPyInit_faster_hexbytes, "6a32f4913d613d6a7ddf__mypyc.init_faster_hexbytes", NULL); + if (!capsule) { + goto fail; + } + res = PyObject_SetAttrString(module, "init_faster_hexbytes", capsule); + Py_DECREF(capsule); + if (res < 0) { + goto fail; + } + + extern PyObject *CPyInit_faster_hexbytes____utils(void); + capsule = PyCapsule_New((void *)CPyInit_faster_hexbytes____utils, "6a32f4913d613d6a7ddf__mypyc.init_faster_hexbytes____utils", NULL); + if (!capsule) { + goto fail; + } + res = PyObject_SetAttrString(module, "init_faster_hexbytes____utils", capsule); + Py_DECREF(capsule); + if (res < 0) { + goto fail; + } + + extern PyObject *CPyInit_faster_hexbytes___main(void); + capsule = PyCapsule_New((void *)CPyInit_faster_hexbytes___main, "6a32f4913d613d6a7ddf__mypyc.init_faster_hexbytes___main", NULL); + if (!capsule) { + goto fail; + } + res = PyObject_SetAttrString(module, "init_faster_hexbytes___main", capsule); + Py_DECREF(capsule); + if (res < 0) { + goto fail; + } + + return 0; + fail: + return -1; +} +static PyModuleDef module_def_6a32f4913d613d6a7ddf__mypyc = { + PyModuleDef_HEAD_INIT, + .m_name = "6a32f4913d613d6a7ddf__mypyc", + .m_doc = NULL, + .m_size = -1, + .m_methods = NULL, +}; +PyMODINIT_FUNC PyInit_6a32f4913d613d6a7ddf__mypyc(void) { + static PyObject *module = NULL; + if (module) { + Py_INCREF(module); + return module; + } + module = PyModule_Create(&module_def_6a32f4913d613d6a7ddf__mypyc); + if (!module) { + return NULL; + } + if (exec_6a32f4913d613d6a7ddf__mypyc(module) < 0) { + Py_DECREF(module); + return NULL; + } + return module; +} diff --git a/build/__native_6a32f4913d613d6a7ddf.h b/build/__native_6a32f4913d613d6a7ddf.h new file mode 100644 index 0000000..d1ad01d --- /dev/null +++ b/build/__native_6a32f4913d613d6a7ddf.h @@ -0,0 +1,72 @@ +#ifndef MYPYC_NATIVE_6a32f4913d613d6a7ddf_H +#define MYPYC_NATIVE_6a32f4913d613d6a7ddf_H +#include +#include +#ifndef MYPYC_DECLARED_tuple_T2OO +#define MYPYC_DECLARED_tuple_T2OO +typedef struct tuple_T2OO { + PyObject *f0; + PyObject *f1; +} tuple_T2OO; +#endif + +#ifndef MYPYC_DECLARED_tuple_T3OOO +#define MYPYC_DECLARED_tuple_T3OOO +typedef struct tuple_T3OOO { + PyObject *f0; + PyObject *f1; + PyObject *f2; +} tuple_T3OOO; +#endif + +#ifndef MYPYC_DECLARED_tuple_T2OT2OO +#define MYPYC_DECLARED_tuple_T2OT2OO +typedef struct tuple_T2OT2OO { + PyObject *f0; + tuple_T2OO f1; +} tuple_T2OT2OO; +#endif + +#ifndef MYPYC_DECLARED_tuple_T6OOOOOO +#define MYPYC_DECLARED_tuple_T6OOOOOO +typedef struct tuple_T6OOOOOO { + PyObject *f0; + PyObject *f1; + PyObject *f2; + PyObject *f3; + PyObject *f4; + PyObject *f5; +} tuple_T6OOOOOO; +#endif + +typedef struct { + PyObject_HEAD + CPyVTableItem *vtable; + vectorcallfunc vectorcall; +} faster_hexbytes___main_____new___3_HexBytes_objObject; + +typedef struct { + PyObject_HEAD + CPyVTableItem *vtable; + vectorcallfunc vectorcall; +} faster_hexbytes___main_____getitem___3_HexBytes_objObject; + +typedef struct { + PyObject_HEAD + CPyVTableItem *vtable; + vectorcallfunc vectorcall; +} faster_hexbytes___main_____repr___3_HexBytes_objObject; + +typedef struct { + PyObject_HEAD + CPyVTableItem *vtable; + vectorcallfunc vectorcall; +} faster_hexbytes___main___to_0x_hex_HexBytes_objObject; + +typedef struct { + PyObject_HEAD + CPyVTableItem *vtable; + vectorcallfunc vectorcall; +} faster_hexbytes___main_____reduce___3_HexBytes_objObject; + +#endif diff --git a/build/__native_internal_6a32f4913d613d6a7ddf.h b/build/__native_internal_6a32f4913d613d6a7ddf.h new file mode 100644 index 0000000..a093531 --- /dev/null +++ b/build/__native_internal_6a32f4913d613d6a7ddf.h @@ -0,0 +1,81 @@ +#ifndef MYPYC_NATIVE_INTERNAL_6a32f4913d613d6a7ddf_H +#define MYPYC_NATIVE_INTERNAL_6a32f4913d613d6a7ddf_H +#include +#include +#include "__native_6a32f4913d613d6a7ddf.h" + +int CPyGlobalsInit(void); + +extern PyObject *CPyStatics[87]; +extern const char * const CPyLit_Str[]; +extern const char * const CPyLit_Bytes[]; +extern const char * const CPyLit_Int[]; +extern const double CPyLit_Float[]; +extern const double CPyLit_Complex[]; +extern const int CPyLit_Tuple[]; +extern const int CPyLit_FrozenSet[]; +extern CPyModule *CPyModule_faster_hexbytes__internal; +extern CPyModule *CPyModule_faster_hexbytes; +extern PyObject *CPyStatic_faster_hexbytes___globals; +extern CPyModule *CPyModule_builtins; +extern CPyModule *CPyModule_importlib___metadata; +extern CPyModule *CPyModule_faster_hexbytes___main__internal; +extern CPyModule *CPyModule_faster_hexbytes___main; +extern CPyModule *CPyModule_faster_hexbytes____utils__internal; +extern CPyModule *CPyModule_faster_hexbytes____utils; +extern PyObject *CPyStatic__utils___globals; +extern CPyModule *CPyModule_binascii; +extern CPyModule *CPyModule_typing; +extern PyObject *CPyStatic_main___globals; +extern CPyModule *CPyModule_hexbytes___main; +extern CPyModule *CPyModule_mypy_extensions; +extern CPyModule *CPyModule_typing_extensions; +extern char CPyDef_faster_hexbytes_____top_level__(void); +extern PyObject *CPyStatic__utils___unhexlify; +extern PyObject *CPyDef__utils___to_bytes(PyObject *cpy_r_val); +extern PyObject *CPyPy__utils___to_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef__utils___hexstr_to_bytes(PyObject *cpy_r_hexstr); +extern PyObject *CPyPy__utils___hexstr_to_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef__utils_____top_level__(void); +extern PyObject *CPyStatic_main____bytes_new; +extern PyTypeObject *CPyType_main___HexBytes; +extern PyTypeObject *CPyType_main____HexBytesSubclass1; +extern PyTypeObject *CPyType_main____HexBytesSubclass2; +extern PyTypeObject *CPyType_main____HexBytesSubclass3; +extern PyTypeObject *CPyType_main_____new___3_HexBytes_obj; +extern PyObject *CPyDef_main_____new___3_HexBytes_obj(void); +extern CPyThreadLocal faster_hexbytes___main_____new___3_HexBytes_objObject *main_____new___3_HexBytes_obj_free_instance; +extern PyTypeObject *CPyType_main_____getitem___3_HexBytes_obj; +extern PyObject *CPyDef_main_____getitem___3_HexBytes_obj(void); +extern CPyThreadLocal faster_hexbytes___main_____getitem___3_HexBytes_objObject *main_____getitem___3_HexBytes_obj_free_instance; +extern PyTypeObject *CPyType_main_____repr___3_HexBytes_obj; +extern PyObject *CPyDef_main_____repr___3_HexBytes_obj(void); +extern CPyThreadLocal faster_hexbytes___main_____repr___3_HexBytes_objObject *main_____repr___3_HexBytes_obj_free_instance; +extern PyTypeObject *CPyType_main___to_0x_hex_HexBytes_obj; +extern PyObject *CPyDef_main___to_0x_hex_HexBytes_obj(void); +extern CPyThreadLocal faster_hexbytes___main___to_0x_hex_HexBytes_objObject *main___to_0x_hex_HexBytes_obj_free_instance; +extern PyTypeObject *CPyType_main_____reduce___3_HexBytes_obj; +extern PyObject *CPyDef_main_____reduce___3_HexBytes_obj(void); +extern CPyThreadLocal faster_hexbytes___main_____reduce___3_HexBytes_objObject *main_____reduce___3_HexBytes_obj_free_instance; +extern PyObject *CPyDef_main_____new___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +extern PyObject *CPyPy_main_____new___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_main_____new___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_val); +extern PyObject *CPyPy_main_____new___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_main_____getitem___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +extern PyObject *CPyPy_main_____getitem___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_main_____getitem___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self, PyObject *cpy_r_key); +extern PyObject *CPyPy_main_____getitem___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_main_____repr___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +extern PyObject *CPyPy_main_____repr___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_main_____repr___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self); +extern PyObject *CPyPy_main_____repr___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_main___to_0x_hex_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +extern PyObject *CPyPy_main___to_0x_hex_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_main___to_0x_hex_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self); +extern PyObject *CPyPy_main___to_0x_hex_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_main_____reduce___3_HexBytes_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +extern PyObject *CPyPy_main_____reduce___3_HexBytes_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern tuple_T2OT2OO CPyDef_main_____reduce___3_HexBytes_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_self); +extern PyObject *CPyPy_main_____reduce___3_HexBytes_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_main_____top_level__(void); +#endif diff --git a/build/faster_hexbytes.c b/build/faster_hexbytes.c new file mode 100644 index 0000000..c0722af --- /dev/null +++ b/build/faster_hexbytes.c @@ -0,0 +1,24 @@ +#ifndef DIFFCHECK_PLACEHOLDER +#define DIFFCHECK_PLACEHOLDER 0 +#endif +#include + +PyMODINIT_FUNC +PyInit_faster_hexbytes(void) +{ + PyObject *tmp; + if (!(tmp = PyImport_ImportModule("6a32f4913d613d6a7ddf__mypyc"))) return NULL; + PyObject *capsule = PyObject_GetAttrString(tmp, "init_faster_hexbytes"); + Py_DECREF(tmp); + if (capsule == NULL) return NULL; + void *init_func = PyCapsule_GetPointer(capsule, "6a32f4913d613d6a7ddf__mypyc.init_faster_hexbytes"); + Py_DECREF(capsule); + if (!init_func) { + return NULL; + } + return ((PyObject *(*)(void))init_func)(); +} + +// distutils sometimes spuriously tells cl to export CPyInit___init__, +// so provide that so it chills out +PyMODINIT_FUNC PyInit___init__(void) { return PyInit_faster_hexbytes(); } diff --git a/build/faster_hexbytes/_utils.c b/build/faster_hexbytes/_utils.c new file mode 100644 index 0000000..d9858f5 --- /dev/null +++ b/build/faster_hexbytes/_utils.c @@ -0,0 +1,21 @@ +#include + +PyMODINIT_FUNC +PyInit__utils(void) +{ + PyObject *tmp; + if (!(tmp = PyImport_ImportModule("6a32f4913d613d6a7ddf__mypyc"))) return NULL; + PyObject *capsule = PyObject_GetAttrString(tmp, "init_faster_hexbytes____utils"); + Py_DECREF(tmp); + if (capsule == NULL) return NULL; + void *init_func = PyCapsule_GetPointer(capsule, "6a32f4913d613d6a7ddf__mypyc.init_faster_hexbytes____utils"); + Py_DECREF(capsule); + if (!init_func) { + return NULL; + } + return ((PyObject *(*)(void))init_func)(); +} + +// distutils sometimes spuriously tells cl to export CPyInit___init__, +// so provide that so it chills out +PyMODINIT_FUNC PyInit___init__(void) { return PyInit__utils(); } diff --git a/build/faster_hexbytes/main.c b/build/faster_hexbytes/main.c new file mode 100644 index 0000000..12ae3ec --- /dev/null +++ b/build/faster_hexbytes/main.c @@ -0,0 +1,21 @@ +#include + +PyMODINIT_FUNC +PyInit_main(void) +{ + PyObject *tmp; + if (!(tmp = PyImport_ImportModule("6a32f4913d613d6a7ddf__mypyc"))) return NULL; + PyObject *capsule = PyObject_GetAttrString(tmp, "init_faster_hexbytes___main"); + Py_DECREF(tmp); + if (capsule == NULL) return NULL; + void *init_func = PyCapsule_GetPointer(capsule, "6a32f4913d613d6a7ddf__mypyc.init_faster_hexbytes___main"); + Py_DECREF(capsule); + if (!init_func) { + return NULL; + } + return ((PyObject *(*)(void))init_func)(); +} + +// distutils sometimes spuriously tells cl to export CPyInit___init__, +// so provide that so it chills out +PyMODINIT_FUNC PyInit___init__(void) { return PyInit_main(); } diff --git a/build/ops.txt b/build/ops.txt new file mode 100644 index 0000000..8dfadfc --- /dev/null +++ b/build/ops.txt @@ -0,0 +1,1862 @@ +def __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object +L0: + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool +L1: + inc_ref __mypyc_self__ + return __mypyc_self__ +L2: + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 +L3: + return r2 +L4: + r3 = :: object + return r3 + +def __new___HexBytes_obj.__call__(__mypyc_self__, cls, val): + __mypyc_self__ :: faster_hexbytes.main.__new___HexBytes_obj + cls :: object + val :: union[bytes, str, bool, object, int] + r0 :: bytes + r1 :: object + r2 :: bool + r3 :: object[2] + r4 :: object_ptr + r5 :: object + r6, r7 :: faster_hexbytes.main.HexBytes +L0: + r0 = to_bytes(val) + if is_error(r0) goto L7 (error at __new__:50) else goto L1 +L1: + r1 = faster_hexbytes.main._bytes_new :: static + if is_error(r1) goto L8 else goto L4 +L2: + r2 = raise NameError('value for final name "_bytes_new" was not set') + if not r2 goto L7 (error at __new__:51) else goto L3 :: bool +L3: + unreachable +L4: + r3 = [cls, r0] + r4 = load_address r3 + r5 = PyObject_Vectorcall(r1, r4, 2, 0) + if is_error(r5) goto L9 (error at __new__:51) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:51) else goto L6 +L6: + return r6 +L7: + r7 = :: faster_hexbytes.main.HexBytes + return r7 +L8: + dec_ref r0 + goto L2 +L9: + dec_ref r0 + goto L7 + +def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object +L0: + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool +L1: + inc_ref __mypyc_self__ + return __mypyc_self__ +L2: + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 +L3: + return r2 +L4: + r3 = :: object + return r3 + +def __getitem___HexBytes_obj.__call__(__mypyc_self__, self, key): + __mypyc_self__ :: faster_hexbytes.main.__getitem___HexBytes_obj + self :: faster_hexbytes.main.HexBytes + key, r0 :: object + r1 :: str + r2 :: object[3] + r3 :: object_ptr + r4 :: object + r5 :: union[int, bytes] + r6 :: bit + r7 :: int + r8, r9, r10 :: object + r11 :: bit + r12 :: bytes + r13 :: object + r14 :: object[1] + r15 :: object_ptr + r16 :: object + r17 :: faster_hexbytes.main.HexBytes + r18 :: bytes + r19 :: object[1] + r20 :: object_ptr + r21 :: object + r22 :: faster_hexbytes.main.HexBytes + r23 :: union[int, faster_hexbytes.main.HexBytes] +L0: + r0 = load_address PyBytes_Type + r1 = '__getitem__' + r2 = [r0, self, key] + r3 = load_address r2 + r4 = PyObject_VectorcallMethod(r1, r3, 9223372036854775811, 0) + if is_error(r4) goto L14 (error at __getitem__:64) else goto L1 +L1: + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:64) else goto L2 +L2: + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool +L3: + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:66) else goto L4 +L4: + r8 = box(int, r7) + return r8 +L5: + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool +L6: + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:70) else goto L7 +L7: + r13 = faster_hexbytes.main.HexBytes :: type + r14 = [r12] + r15 = load_address r14 + r16 = PyObject_Vectorcall(r13, r15, 1, 0) + if is_error(r16) goto L16 (error at __getitem__:70) else goto L8 +L8: + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:70) else goto L9 +L9: + return r17 +L10: + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:71) else goto L11 +L11: + r19 = [r18] + r20 = load_address r19 + r21 = PyObject_Vectorcall(r9, r20, 1, 0) + dec_ref r9 + if is_error(r21) goto L18 (error at __getitem__:71) else goto L12 +L12: + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:71) else goto L13 +L13: + return r22 +L14: + r23 = :: union[int, faster_hexbytes.main.HexBytes] + return r23 +L15: + dec_ref r9 + goto L6 +L16: + dec_ref r12 + goto L14 +L17: + dec_ref r9 + goto L14 +L18: + dec_ref r18 + goto L14 + +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object +L0: + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool +L1: + inc_ref __mypyc_self__ + return __mypyc_self__ +L2: + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 +L3: + return r2 +L4: + r3 = :: object + return r3 + +def __repr___HexBytes_obj.__call__(__mypyc_self__, self): + __mypyc_self__ :: faster_hexbytes.main.__repr___HexBytes_obj + self :: faster_hexbytes.main.HexBytes + r0, r1 :: str + r2 :: object[1] + r3 :: object_ptr + r4 :: object + r5, r6, r7, r8 :: str +L0: + r0 = "HexBytes('0x" + r1 = 'hex' + r2 = [self] + r3 = load_address r2 + r4 = PyObject_VectorcallMethod(r1, r3, 9223372036854775809, 0) + if is_error(r4) goto L4 (error at __repr__:74) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at __repr__:74) else goto L2 +L2: + r6 = "')" + r7 = CPyStr_Build(3, r0, r5, r6) + dec_ref r5 + if is_error(r7) goto L4 (error at __repr__:74) else goto L3 +L3: + return r7 +L4: + r8 = :: str + return r8 + +def to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object +L0: + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool +L1: + inc_ref __mypyc_self__ + return __mypyc_self__ +L2: + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 +L3: + return r2 +L4: + r3 = :: object + return r3 + +def to_0x_hex_HexBytes_obj.__call__(__mypyc_self__, self): + __mypyc_self__ :: faster_hexbytes.main.to_0x_hex_HexBytes_obj + self :: faster_hexbytes.main.HexBytes + r0, r1 :: str + r2 :: object[1] + r3 :: object_ptr + r4 :: object + r5, r6, r7 :: str +L0: + r0 = '0x' + r1 = 'hex' + r2 = [self] + r3 = load_address r2 + r4 = PyObject_VectorcallMethod(r1, r3, 9223372036854775809, 0) + if is_error(r4) goto L4 (error at to_0x_hex:80) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:80) else goto L2 +L2: + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:80) else goto L3 +L3: + return r6 +L4: + r7 = :: str + return r7 + +def __reduce___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object +L0: + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool +L1: + inc_ref __mypyc_self__ + return __mypyc_self__ +L2: + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 +L3: + return r2 +L4: + r3 = :: object + return r3 + +def __reduce___HexBytes_obj.__call__(__mypyc_self__, self): + __mypyc_self__ :: faster_hexbytes.main.__reduce___HexBytes_obj + self :: faster_hexbytes.main.HexBytes + r0 :: object + r1 :: bool + r2, r3 :: object + r4 :: object[1] + r5 :: object_ptr + r6 :: object + r7 :: bytes + r8 :: tuple[object, bytes] + r9, r10 :: tuple[object, tuple[object, bytes]] +L0: + r0 = faster_hexbytes.main._bytes_new :: static + if is_error(r0) goto L1 else goto L3 +L1: + r1 = raise NameError('value for final name "_bytes_new" was not set') + if not r1 goto L6 (error at __reduce__:90) else goto L2 :: bool +L2: + unreachable +L3: + r2 = CPy_TYPE(self) + r3 = load_address PyBytes_Type + r4 = [self] + r5 = load_address r4 + r6 = PyObject_Vectorcall(r3, r5, 1, 0) + if is_error(r6) goto L7 (error at __reduce__:90) else goto L4 +L4: + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:90) else goto L5 +L5: + r8 = (r2, r7) + inc_ref r0 + r9 = (r0, r8) + return r9 +L6: + r10 = :: tuple[object, tuple[object, bytes]] + return r10 +L7: + dec_ref r2 + goto L6 + +def __top_level__(): + r0, r1 :: object + r2 :: bit + r3 :: str + r4, r5 :: object + r6 :: str + r7 :: dict + r8 :: object + r9 :: object_ptr + r10 :: object_ptr[1] + r11 :: c_ptr + r12 :: native_int[1] + r13 :: c_ptr + r14 :: object + r15 :: dict + r16, r17 :: str + r18 :: bit + r19 :: object + r20 :: str + r21 :: dict + r22, r23 :: object + r24 :: str + r25 :: dict + r26, r27 :: object + r28 :: str + r29 :: dict + r30 :: object + r31 :: dict + r32 :: str + r33, r34, r35, r36, r37 :: object + r38 :: str + r39, r40, r41 :: object + r42 :: str + r43 :: object + r44 :: tuple[object, object, object, object, object, object] + r45, r46 :: object + r47 :: dict + r48 :: str + r49 :: i32 + r50 :: bit + r51 :: object + r52 :: str + r53 :: object + r54 :: dict + r55 :: str + r56 :: i32 + r57 :: bit + r58 :: object + r59 :: str + r60 :: object + r61 :: tuple + r62, r63 :: object + r64 :: str + r65 :: bool + r66, r67 :: str + r68 :: object + r69 :: object[2] + r70 :: object_ptr + r71 :: object + r72, r73, r74, r75 :: dict + r76 :: faster_hexbytes.main.__new___HexBytes_obj + r77 :: object + r78 :: str + r79 :: object + r80 :: object[1] + r81 :: object_ptr + r82 :: object + r83 :: str + r84 :: i32 + r85 :: bit + r86 :: faster_hexbytes.main.__getitem___HexBytes_obj + r87 :: str + r88 :: i32 + r89 :: bit + r90 :: faster_hexbytes.main.__repr___HexBytes_obj + r91 :: str + r92 :: i32 + r93 :: bit + r94 :: faster_hexbytes.main.to_0x_hex_HexBytes_obj + r95 :: str + r96 :: i32 + r97 :: bit + r98 :: faster_hexbytes.main.__reduce___HexBytes_obj + r99 :: str + r100 :: i32 + r101 :: bit + r102, r103 :: str + r104 :: i32 + r105 :: bit + r106, r107 :: str + r108 :: i32 + r109 :: bit + r110, r111 :: str + r112 :: i32 + r113 :: bit + r114 :: object[3] + r115 :: object_ptr + r116 :: object + r117 :: dict + r118 :: str + r119, r120, r121 :: object + r122 :: object[2] + r123 :: object_ptr + r124, r125 :: object + r126 :: object[1] + r127 :: object_ptr + r128 :: object + r129 :: dict + r130 :: str + r131 :: i32 + r132 :: bit + r133 :: object + r134 :: dict + r135 :: str + r136 :: object + r137 :: tuple + r138, r139 :: object + r140 :: str + r141 :: bool + r142, r143 :: str + r144 :: object + r145 :: object[2] + r146 :: object_ptr + r147 :: object + r148, r149, r150, r151 :: dict + r152, r153 :: str + r154 :: i32 + r155 :: bit + r156, r157 :: str + r158 :: i32 + r159 :: bit + r160, r161 :: str + r162 :: i32 + r163 :: bit + r164 :: object[3] + r165 :: object_ptr + r166 :: object + r167 :: dict + r168 :: str + r169, r170 :: object + r171 :: object[1] + r172 :: object_ptr + r173, r174 :: object + r175 :: object[1] + r176 :: object_ptr + r177 :: object + r178 :: dict + r179 :: str + r180 :: i32 + r181 :: bit + r182 :: object + r183 :: dict + r184 :: str + r185 :: object + r186 :: tuple + r187, r188 :: object + r189 :: str + r190 :: bool + r191, r192 :: str + r193 :: object + r194 :: object[2] + r195 :: object_ptr + r196 :: object + r197, r198, r199, r200 :: dict + r201, r202 :: str + r203 :: i32 + r204 :: bit + r205, r206 :: str + r207 :: i32 + r208 :: bit + r209, r210 :: str + r211 :: i32 + r212 :: bit + r213 :: object[3] + r214 :: object_ptr + r215 :: object + r216 :: dict + r217 :: str + r218, r219 :: object + r220 :: object[1] + r221 :: object_ptr + r222, r223 :: object + r224 :: object[1] + r225 :: object_ptr + r226 :: object + r227 :: dict + r228 :: str + r229 :: i32 + r230 :: bit + r231 :: object + r232 :: dict + r233 :: str + r234 :: object + r235 :: tuple + r236, r237 :: object + r238 :: str + r239 :: bool + r240, r241 :: str + r242 :: object + r243 :: object[2] + r244 :: object_ptr + r245 :: object + r246, r247, r248, r249 :: dict + r250, r251 :: str + r252 :: i32 + r253 :: bit + r254, r255 :: str + r256 :: i32 + r257 :: bit + r258, r259 :: str + r260 :: i32 + r261 :: bit + r262 :: object[3] + r263 :: object_ptr + r264 :: object + r265 :: dict + r266 :: str + r267, r268 :: object + r269 :: object[1] + r270 :: object_ptr + r271, r272 :: object + r273 :: object[1] + r274 :: object_ptr + r275 :: object + r276 :: dict + r277 :: str + r278 :: i32 + r279 :: bit + r280 :: object + r281 :: None +L0: + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool +L1: + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L105 (error at :-1) else goto L2 +L2: + builtins = r4 :: module + dec_ref r4 +L3: + r5 = ('TYPE_CHECKING', 'Callable', 'Final', 'Tuple', 'Type', 'Union', 'overload') + r6 = 'typing' + r7 = faster_hexbytes.main.globals :: static + r8 = CPyImport_ImportFromMany(r6, r5, r5, r7) + if is_error(r8) goto L105 (error at :1) else goto L4 +L4: + typing = r8 :: module + dec_ref r8 + r9 = load_address hexbytes.main :: module + r10 = [r9] + r11 = load_address r10 + r12 = [14] + r13 = load_address r12 + r14 = (('hexbytes.main', 'hexbytes.main', 'hexbytes'),) + r15 = faster_hexbytes.main.globals :: static + r16 = 'faster_hexbytes/main.py' + r17 = '' + r18 = CPyImport_ImportMany(r14, r11, r15, r16, r17, r13) + if not r18 goto L105 else goto L5 :: bool +L5: + r19 = ('mypyc_attr',) + r20 = 'mypy_extensions' + r21 = faster_hexbytes.main.globals :: static + r22 = CPyImport_ImportFromMany(r20, r19, r19, r21) + if is_error(r22) goto L105 (error at :15) else goto L6 +L6: + mypy_extensions = r22 :: module + dec_ref r22 + r23 = ('Self',) + r24 = 'typing_extensions' + r25 = faster_hexbytes.main.globals :: static + r26 = CPyImport_ImportFromMany(r24, r23, r23, r25) + if is_error(r26) goto L105 (error at :18) else goto L7 +L7: + typing_extensions = r26 :: module + dec_ref r26 + r27 = ('to_bytes',) + r28 = 'faster_hexbytes._utils' + r29 = faster_hexbytes.main.globals :: static + r30 = CPyImport_ImportFromMany(r28, r27, r27, r29) + if is_error(r30) goto L105 (error at :22) else goto L8 +L8: + faster_hexbytes._utils = r30 :: module + dec_ref r30 + if 0 goto L9 else goto L9 :: bool +L9: + r31 = faster_hexbytes.main.globals :: static + r32 = 'Union' + r33 = CPyDict_GetItem(r31, r32) + if is_error(r33) goto L105 (error at :32) else goto L10 +L10: + r34 = load_address PyBytes_Type + r35 = load_address PyUnicode_Type + r36 = load_address PyBool_Type + r37 = builtins :: module + r38 = 'bytearray' + r39 = CPyObject_GetAttr(r37, r38) + if is_error(r39) goto L106 (error at :32) else goto L11 +L11: + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L107 (error at :32) else goto L12 +L12: + inc_ref r34 + inc_ref r35 + inc_ref r36 + inc_ref r40 + r44 = (r34, r35, r36, r39, r40, r43) + r45 = box(tuple[object, object, object, object, object, object], r44) + r46 = PyObject_GetItem(r33, r45) + dec_ref r33 + dec_ref r45 + if is_error(r46) goto L105 (error at :32) else goto L13 +L13: + r47 = faster_hexbytes.main.globals :: static + r48 = 'BytesLike' + r49 = CPyDict_SetItem(r47, r48, r46) + dec_ref r46 + r50 = r49 >= 0 :: signed + if not r50 goto L105 (error at :32) else goto L14 :: bool +L14: + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L105 (error at :34) else goto L15 +L15: + faster_hexbytes.main._bytes_new = r53 :: static + r54 = faster_hexbytes.main.globals :: static + r55 = '_bytes_new' + r56 = CPyDict_SetItem(r54, r55, r53) + dec_ref r53 + r57 = r56 >= 0 :: signed + if not r57 goto L105 (error at :34) else goto L16 :: bool +L16: + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L105 (error at :38) else goto L17 +L17: + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L105 (error at :38) else goto L18 +L18: + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L108 (error at :38) else goto L19 +L19: + r64 = '__prepare__' + r65 = PyObject_HasAttr(r63, r64) + if r65 goto L20 else goto L24 :: bool +L20: + r66 = 'HexBytes' + r67 = '__prepare__' + r68 = CPyObject_GetAttr(r63, r67) + if is_error(r68) goto L108 (error at :38) else goto L21 +L21: + r69 = [r66, r61] + r70 = load_address r69 + r71 = PyObject_Vectorcall(r68, r70, 2, 0) + dec_ref r68 + if is_error(r71) goto L108 (error at :38) else goto L22 +L22: + r72 = cast(dict, r71) + if is_error(r72) goto L108 (error at :38) else goto L23 +L23: + r73 = r72 + goto L26 +L24: + r74 = PyDict_New() + if is_error(r74) goto L108 (error at :38) else goto L25 +L25: + r73 = r74 +L26: + r75 = PyDict_New() + if is_error(r75) goto L109 (error at :38) else goto L27 +L27: + r76 = __new___HexBytes_obj() + if is_error(r76) goto L110 (error at :49) else goto L28 +L28: + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L111 (error at :49) else goto L29 +L29: + r80 = [r76] + r81 = load_address r80 + r82 = PyObject_Vectorcall(r79, r81, 1, 0) + dec_ref r79 + if is_error(r82) goto L111 (error at :49) else goto L30 +L30: + dec_ref r76 + r83 = '__new__' + r84 = CPyDict_SetItem(r73, r83, r82) + dec_ref r82 + r85 = r84 >= 0 :: signed + if not r85 goto L110 (error at :49) else goto L31 :: bool +L31: + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L110 (error at :61) else goto L32 +L32: + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L110 (error at :61) else goto L33 :: bool +L33: + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L110 (error at :73) else goto L34 +L34: + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L110 (error at :73) else goto L35 :: bool +L35: + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L110 (error at :76) else goto L36 +L36: + r95 = 'to_0x_hex' + r96 = CPyDict_SetItem(r73, r95, r94) + dec_ref r94 + r97 = r96 >= 0 :: signed + if not r97 goto L110 (error at :76) else goto L37 :: bool +L37: + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L110 (error at :82) else goto L38 +L38: + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L110 (error at :82) else goto L39 :: bool +L39: + r102 = 'HexBytes' + r103 = '__annotations__' + r104 = CPyDict_SetItem(r73, r103, r75) + dec_ref r75 + r105 = r104 >= 0 :: signed + if not r105 goto L109 (error at :38) else goto L40 :: bool +L40: + r106 = 'mypyc filler docstring' + r107 = '__doc__' + r108 = CPyDict_SetItem(r73, r107, r106) + r109 = r108 >= 0 :: signed + if not r109 goto L109 (error at :38) else goto L41 :: bool +L41: + r110 = 'faster_hexbytes.main' + r111 = '__module__' + r112 = CPyDict_SetItem(r73, r111, r110) + r113 = r112 >= 0 :: signed + if not r113 goto L109 (error at :38) else goto L42 :: bool +L42: + r114 = [r102, r61, r73] + r115 = load_address r114 + r116 = PyObject_Vectorcall(r63, r115, 3, 0) + if is_error(r116) goto L109 (error at :38) else goto L43 +L43: + dec_ref r73 + dec_ref r61 + r117 = faster_hexbytes.main.globals :: static + r118 = 'mypyc_attr' + r119 = CPyDict_GetItem(r117, r118) + if is_error(r119) goto L112 (error at :37) else goto L44 +L44: + r120 = box(bool, 0) + r121 = box(bool, 1) + r122 = [r120, r121] + r123 = load_address r122 + r124 = ('native_class', 'allow_interpreted_subclasses') + r125 = PyObject_Vectorcall(r119, r123, 0, r124) + dec_ref r119 + if is_error(r125) goto L112 (error at :37) else goto L45 +L45: + r126 = [r116] + r127 = load_address r126 + r128 = PyObject_Vectorcall(r125, r127, 1, 0) + dec_ref r125 + if is_error(r128) goto L112 (error at :38) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r128 :: type + r129 = faster_hexbytes.main.globals :: static + r130 = 'HexBytes' + r131 = PyDict_SetItem(r129, r130, r128) + dec_ref r128 + r132 = r131 >= 0 :: signed + if not r132 goto L105 (error at :38) else goto L47 :: bool +L47: + r133 = faster_hexbytes.main.HexBytes :: type + r134 = faster_hexbytes.main.globals :: static + r135 = 'HexBytes' + r136 = CPyDict_GetItem(r134, r135) + if is_error(r136) goto L105 (error at :97) else goto L48 +L48: + r137 = PyTuple_Pack(1, r136) + dec_ref r136 + if is_error(r137) goto L105 (error at :97) else goto L49 +L49: + r138 = load_address PyType_Type + r139 = CPy_CalculateMetaclass(r138, r137) + if is_error(r139) goto L113 (error at :97) else goto L50 +L50: + r140 = '__prepare__' + r141 = PyObject_HasAttr(r139, r140) + if r141 goto L51 else goto L55 :: bool +L51: + r142 = '_HexBytesSubclass1' + r143 = '__prepare__' + r144 = CPyObject_GetAttr(r139, r143) + if is_error(r144) goto L113 (error at :97) else goto L52 +L52: + r145 = [r142, r137] + r146 = load_address r145 + r147 = PyObject_Vectorcall(r144, r146, 2, 0) + dec_ref r144 + if is_error(r147) goto L113 (error at :97) else goto L53 +L53: + r148 = cast(dict, r147) + if is_error(r148) goto L113 (error at :97) else goto L54 +L54: + r149 = r148 + goto L57 +L55: + r150 = PyDict_New() + if is_error(r150) goto L113 (error at :97) else goto L56 +L56: + r149 = r150 +L57: + r151 = PyDict_New() + if is_error(r151) goto L114 (error at :97) else goto L58 +L58: + r152 = '_HexBytesSubclass1' + r153 = '__annotations__' + r154 = CPyDict_SetItem(r149, r153, r151) + dec_ref r151 + r155 = r154 >= 0 :: signed + if not r155 goto L114 (error at :97) else goto L59 :: bool +L59: + r156 = 'mypyc filler docstring' + r157 = '__doc__' + r158 = CPyDict_SetItem(r149, r157, r156) + r159 = r158 >= 0 :: signed + if not r159 goto L114 (error at :97) else goto L60 :: bool +L60: + r160 = 'faster_hexbytes.main' + r161 = '__module__' + r162 = CPyDict_SetItem(r149, r161, r160) + r163 = r162 >= 0 :: signed + if not r163 goto L114 (error at :97) else goto L61 :: bool +L61: + r164 = [r152, r137, r149] + r165 = load_address r164 + r166 = PyObject_Vectorcall(r139, r165, 3, 0) + if is_error(r166) goto L114 (error at :97) else goto L62 +L62: + dec_ref r149 + dec_ref r137 + r167 = faster_hexbytes.main.globals :: static + r168 = 'mypyc_attr' + r169 = CPyDict_GetItem(r167, r168) + if is_error(r169) goto L115 (error at :96) else goto L63 +L63: + r170 = box(bool, 0) + r171 = [r170] + r172 = load_address r171 + r173 = ('native_class',) + r174 = PyObject_Vectorcall(r169, r172, 0, r173) + dec_ref r169 + if is_error(r174) goto L115 (error at :96) else goto L64 +L64: + r175 = [r166] + r176 = load_address r175 + r177 = PyObject_Vectorcall(r174, r176, 1, 0) + dec_ref r174 + if is_error(r177) goto L115 (error at :97) else goto L65 +L65: + dec_ref r166 + faster_hexbytes.main._HexBytesSubclass1 = r177 :: type + r178 = faster_hexbytes.main.globals :: static + r179 = '_HexBytesSubclass1' + r180 = PyDict_SetItem(r178, r179, r177) + dec_ref r177 + r181 = r180 >= 0 :: signed + if not r181 goto L105 (error at :97) else goto L66 :: bool +L66: + r182 = faster_hexbytes.main._HexBytesSubclass1 :: type + r183 = faster_hexbytes.main.globals :: static + r184 = 'HexBytes' + r185 = CPyDict_GetItem(r183, r184) + if is_error(r185) goto L105 (error at :99) else goto L67 +L67: + r186 = PyTuple_Pack(1, r185) + dec_ref r185 + if is_error(r186) goto L105 (error at :99) else goto L68 +L68: + r187 = load_address PyType_Type + r188 = CPy_CalculateMetaclass(r187, r186) + if is_error(r188) goto L116 (error at :99) else goto L69 +L69: + r189 = '__prepare__' + r190 = PyObject_HasAttr(r188, r189) + if r190 goto L70 else goto L74 :: bool +L70: + r191 = '_HexBytesSubclass2' + r192 = '__prepare__' + r193 = CPyObject_GetAttr(r188, r192) + if is_error(r193) goto L116 (error at :99) else goto L71 +L71: + r194 = [r191, r186] + r195 = load_address r194 + r196 = PyObject_Vectorcall(r193, r195, 2, 0) + dec_ref r193 + if is_error(r196) goto L116 (error at :99) else goto L72 +L72: + r197 = cast(dict, r196) + if is_error(r197) goto L116 (error at :99) else goto L73 +L73: + r198 = r197 + goto L76 +L74: + r199 = PyDict_New() + if is_error(r199) goto L116 (error at :99) else goto L75 +L75: + r198 = r199 +L76: + r200 = PyDict_New() + if is_error(r200) goto L117 (error at :99) else goto L77 +L77: + r201 = '_HexBytesSubclass2' + r202 = '__annotations__' + r203 = CPyDict_SetItem(r198, r202, r200) + dec_ref r200 + r204 = r203 >= 0 :: signed + if not r204 goto L117 (error at :99) else goto L78 :: bool +L78: + r205 = 'mypyc filler docstring' + r206 = '__doc__' + r207 = CPyDict_SetItem(r198, r206, r205) + r208 = r207 >= 0 :: signed + if not r208 goto L117 (error at :99) else goto L79 :: bool +L79: + r209 = 'faster_hexbytes.main' + r210 = '__module__' + r211 = CPyDict_SetItem(r198, r210, r209) + r212 = r211 >= 0 :: signed + if not r212 goto L117 (error at :99) else goto L80 :: bool +L80: + r213 = [r201, r186, r198] + r214 = load_address r213 + r215 = PyObject_Vectorcall(r188, r214, 3, 0) + if is_error(r215) goto L117 (error at :99) else goto L81 +L81: + dec_ref r198 + dec_ref r186 + r216 = faster_hexbytes.main.globals :: static + r217 = 'mypyc_attr' + r218 = CPyDict_GetItem(r216, r217) + if is_error(r218) goto L118 (error at :98) else goto L82 +L82: + r219 = box(bool, 0) + r220 = [r219] + r221 = load_address r220 + r222 = ('native_class',) + r223 = PyObject_Vectorcall(r218, r221, 0, r222) + dec_ref r218 + if is_error(r223) goto L118 (error at :98) else goto L83 +L83: + r224 = [r215] + r225 = load_address r224 + r226 = PyObject_Vectorcall(r223, r225, 1, 0) + dec_ref r223 + if is_error(r226) goto L118 (error at :99) else goto L84 +L84: + dec_ref r215 + faster_hexbytes.main._HexBytesSubclass2 = r226 :: type + r227 = faster_hexbytes.main.globals :: static + r228 = '_HexBytesSubclass2' + r229 = PyDict_SetItem(r227, r228, r226) + dec_ref r226 + r230 = r229 >= 0 :: signed + if not r230 goto L105 (error at :99) else goto L85 :: bool +L85: + r231 = faster_hexbytes.main._HexBytesSubclass2 :: type + r232 = faster_hexbytes.main.globals :: static + r233 = 'HexBytes' + r234 = CPyDict_GetItem(r232, r233) + if is_error(r234) goto L105 (error at :101) else goto L86 +L86: + r235 = PyTuple_Pack(1, r234) + dec_ref r234 + if is_error(r235) goto L105 (error at :101) else goto L87 +L87: + r236 = load_address PyType_Type + r237 = CPy_CalculateMetaclass(r236, r235) + if is_error(r237) goto L119 (error at :101) else goto L88 +L88: + r238 = '__prepare__' + r239 = PyObject_HasAttr(r237, r238) + if r239 goto L89 else goto L93 :: bool +L89: + r240 = '_HexBytesSubclass3' + r241 = '__prepare__' + r242 = CPyObject_GetAttr(r237, r241) + if is_error(r242) goto L119 (error at :101) else goto L90 +L90: + r243 = [r240, r235] + r244 = load_address r243 + r245 = PyObject_Vectorcall(r242, r244, 2, 0) + dec_ref r242 + if is_error(r245) goto L119 (error at :101) else goto L91 +L91: + r246 = cast(dict, r245) + if is_error(r246) goto L119 (error at :101) else goto L92 +L92: + r247 = r246 + goto L95 +L93: + r248 = PyDict_New() + if is_error(r248) goto L119 (error at :101) else goto L94 +L94: + r247 = r248 +L95: + r249 = PyDict_New() + if is_error(r249) goto L120 (error at :101) else goto L96 +L96: + r250 = '_HexBytesSubclass3' + r251 = '__annotations__' + r252 = CPyDict_SetItem(r247, r251, r249) + dec_ref r249 + r253 = r252 >= 0 :: signed + if not r253 goto L120 (error at :101) else goto L97 :: bool +L97: + r254 = 'mypyc filler docstring' + r255 = '__doc__' + r256 = CPyDict_SetItem(r247, r255, r254) + r257 = r256 >= 0 :: signed + if not r257 goto L120 (error at :101) else goto L98 :: bool +L98: + r258 = 'faster_hexbytes.main' + r259 = '__module__' + r260 = CPyDict_SetItem(r247, r259, r258) + r261 = r260 >= 0 :: signed + if not r261 goto L120 (error at :101) else goto L99 :: bool +L99: + r262 = [r250, r235, r247] + r263 = load_address r262 + r264 = PyObject_Vectorcall(r237, r263, 3, 0) + if is_error(r264) goto L120 (error at :101) else goto L100 +L100: + dec_ref r247 + dec_ref r235 + r265 = faster_hexbytes.main.globals :: static + r266 = 'mypyc_attr' + r267 = CPyDict_GetItem(r265, r266) + if is_error(r267) goto L121 (error at :100) else goto L101 +L101: + r268 = box(bool, 0) + r269 = [r268] + r270 = load_address r269 + r271 = ('native_class',) + r272 = PyObject_Vectorcall(r267, r270, 0, r271) + dec_ref r267 + if is_error(r272) goto L121 (error at :100) else goto L102 +L102: + r273 = [r264] + r274 = load_address r273 + r275 = PyObject_Vectorcall(r272, r274, 1, 0) + dec_ref r272 + if is_error(r275) goto L121 (error at :101) else goto L103 +L103: + dec_ref r264 + faster_hexbytes.main._HexBytesSubclass3 = r275 :: type + r276 = faster_hexbytes.main.globals :: static + r277 = '_HexBytesSubclass3' + r278 = PyDict_SetItem(r276, r277, r275) + dec_ref r275 + r279 = r278 >= 0 :: signed + if not r279 goto L105 (error at :101) else goto L104 :: bool +L104: + r280 = faster_hexbytes.main._HexBytesSubclass3 :: type + return 1 +L105: + r281 = :: None + return r281 +L106: + dec_ref r33 + goto L105 +L107: + dec_ref r33 + dec_ref r39 + goto L105 +L108: + dec_ref r61 + goto L105 +L109: + dec_ref r61 + dec_ref r73 + goto L105 +L110: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L105 +L111: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L105 +L112: + dec_ref r116 + goto L105 +L113: + dec_ref r137 + goto L105 +L114: + dec_ref r137 + dec_ref r149 + goto L105 +L115: + dec_ref r166 + goto L105 +L116: + dec_ref r186 + goto L105 +L117: + dec_ref r186 + dec_ref r198 + goto L105 +L118: + dec_ref r215 + goto L105 +L119: + dec_ref r235 + goto L105 +L120: + dec_ref r235 + dec_ref r247 + goto L105 +L121: + dec_ref r264 + goto L105 + +def __top_level__(): + r0, r1 :: object + r2 :: bit + r3 :: str + r4, r5, r6 :: object + r7 :: str + r8 :: dict + r9, r10 :: object + r11 :: str + r12 :: dict + r13 :: object + r14 :: str + r15 :: list + r16, r17 :: ptr + r18 :: dict + r19 :: str + r20 :: i32 + r21 :: bit + r22 :: str + r23 :: dict + r24 :: str + r25 :: object + r26 :: object[1] + r27 :: object_ptr + r28 :: object + r29 :: str + r30 :: dict + r31 :: str + r32 :: i32 + r33 :: bit + r34 :: None +L0: + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool +L1: + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L12 (error at :-1) else goto L2 +L2: + builtins = r4 :: module + dec_ref r4 +L3: + r5 = ('version',) + r6 = ('__version',) + r7 = 'importlib.metadata' + r8 = faster_hexbytes.globals :: static + r9 = CPyImport_ImportFromMany(r7, r5, r6, r8) + if is_error(r9) goto L12 (error at :1) else goto L4 +L4: + importlib.metadata = r9 :: module + dec_ref r9 + r10 = ('HexBytes',) + r11 = 'faster_hexbytes.main' + r12 = faster_hexbytes.globals :: static + r13 = CPyImport_ImportFromMany(r11, r10, r10, r12) + if is_error(r13) goto L12 (error at :5) else goto L5 +L5: + faster_hexbytes.main = r13 :: module + dec_ref r13 + r14 = 'HexBytes' + r15 = PyList_New(1) + if is_error(r15) goto L12 (error at :9) else goto L6 +L6: + r16 = get_element_ptr r15 ob_item :: PyListObject + r17 = load_mem r16 :: ptr* + inc_ref r14 + set_mem r17, r14 :: builtins.object* + r18 = faster_hexbytes.globals :: static + r19 = '__all__' + r20 = CPyDict_SetItem(r18, r19, r15) + dec_ref r15 + r21 = r20 >= 0 :: signed + if not r21 goto L12 (error at :9) else goto L7 :: bool +L7: + r22 = 'hexbytes' + r23 = faster_hexbytes.globals :: static + r24 = '__version' + r25 = CPyDict_GetItem(r23, r24) + if is_error(r25) goto L12 (error at :11) else goto L8 +L8: + r26 = [r22] + r27 = load_address r26 + r28 = PyObject_Vectorcall(r25, r27, 1, 0) + dec_ref r25 + if is_error(r28) goto L12 (error at :11) else goto L9 +L9: + r29 = cast(str, r28) + if is_error(r29) goto L12 (error at :11) else goto L10 +L10: + r30 = faster_hexbytes.globals :: static + r31 = '__version__' + r32 = CPyDict_SetItem(r30, r31, r29) + dec_ref r29 + r33 = r32 >= 0 :: signed + if not r33 goto L12 (error at :11) else goto L11 :: bool +L11: + return 1 +L12: + r34 = :: None + return r34 + +def to_bytes(val): + val :: union[bytes, str, object, bool, int] + r0 :: bit + r1 :: bytes + r2 :: bit + r3 :: str + r4 :: bytes + r5 :: bit + r6 :: object + r7 :: object[1] + r8 :: object_ptr + r9 :: object + r10 :: bytes + r11 :: bit + r12 :: bool + r13, r14, r15 :: bytes + r16 :: bit + r17 :: int + r18 :: native_int + r19 :: bit + r20 :: native_int + r21, r22 :: bit + r23 :: bool + r24 :: bit + r25 :: str + r26 :: int + r27, r28, r29 :: str + r30 :: object + r31 :: str + r32 :: object + r33 :: object[1] + r34 :: object_ptr + r35 :: object + r36 :: int + r37 :: object + r38 :: str + r39, r40 :: object + r41 :: object[1] + r42 :: object_ptr + r43 :: object + r44 :: str + r45 :: bytes + r46 :: object + r47 :: str + r48 :: object + r49 :: i32 + r50 :: bit + r51 :: bool + r52 :: object + r53 :: object[1] + r54 :: object_ptr + r55 :: object + r56 :: bytes + r57, r58, r59, r60, r61 :: str + r62 :: object[3] + r63 :: object_ptr + r64 :: object + r65, r66 :: str + r67 :: object + r68, r69 :: str + r70 :: object[3] + r71 :: object_ptr + r72 :: object + r73 :: str + r74 :: list + r75, r76, r77, r78, r79, r80 :: ptr + r81 :: str + r82 :: object + r83 :: str + r84 :: object + r85 :: object[1] + r86 :: object_ptr + r87 :: object + r88 :: bytes +L0: + r0 = PyBytes_Check(val) + if r0 goto L1 else goto L3 :: bool +L1: + inc_ref val + r1 = cast(bytes, val) + if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 +L2: + return r1 +L3: + r2 = PyUnicode_Check(val) + if r2 goto L4 else goto L7 :: bool +L4: + inc_ref val + r3 = cast(str, val) + if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 +L5: + r4 = hexstr_to_bytes(r3) + dec_ref r3 + if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 +L6: + return r4 +L7: + r5 = PyByteArray_Check(val) + if r5 goto L8 else goto L11 :: bool +L8: + r6 = load_address PyBytes_Type + r7 = [val] + r8 = load_address r7 + r9 = PyObject_Vectorcall(r6, r8, 1, 0) + if is_error(r9) goto L51 (error at to_bytes:23) else goto L9 +L9: + r10 = cast(bytes, r9) + if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 +L10: + return r10 +L11: + r11 = PyBool_Check(val) + if r11 goto L12 else goto L17 :: bool +L12: + r12 = unbox(bool, val) + if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 +L13: + if r12 goto L14 else goto L15 :: bool +L14: + r13 = b'\x01' + inc_ref r13 + r14 = r13 + goto L16 +L15: + r15 = b'\x00' + inc_ref r15 + r14 = r15 +L16: + return r14 +L17: + r16 = PyLong_Check(val) + if r16 goto L18 else goto L37 :: bool +L18: + r17 = unbox(int, val) + if is_error(r17) goto L51 (error at to_bytes:29) else goto L19 +L19: + r18 = r17 & 1 + r19 = r18 != 0 + if r19 goto L21 else goto L20 :: bool +L20: + r20 = 0 & 1 + r21 = r20 != 0 + if r21 goto L21 else goto L22 :: bool +L21: + r22 = CPyTagged_IsLt_(r17, 0) + r23 = r22 + goto L23 +L22: + r24 = r17 < 0 :: signed + r23 = r24 +L23: + dec_ref r17 :: int + if r23 goto L24 else goto L31 :: bool +L24: + r25 = 'Cannot convert negative integer ' + r26 = unbox(int, val) + if is_error(r26) goto L51 (error at to_bytes:30) else goto L25 +L25: + r27 = CPyTagged_Str(r26) + dec_ref r26 :: int + if is_error(r27) goto L51 (error at to_bytes:30) else goto L26 +L26: + r28 = ' to bytes' + r29 = CPyStr_Build(3, r25, r27, r28) + dec_ref r27 + if is_error(r29) goto L51 (error at to_bytes:30) else goto L27 +L27: + r30 = builtins :: module + r31 = 'ValueError' + r32 = CPyObject_GetAttr(r30, r31) + if is_error(r32) goto L52 (error at to_bytes:30) else goto L28 +L28: + r33 = [r29] + r34 = load_address r33 + r35 = PyObject_Vectorcall(r32, r34, 1, 0) + dec_ref r32 + if is_error(r35) goto L52 (error at to_bytes:30) else goto L29 +L29: + dec_ref r29 + CPy_Raise(r35) + dec_ref r35 + if not 0 goto L51 (error at to_bytes:30) else goto L30 :: bool +L30: + unreachable +L31: + r36 = unbox(int, val) + if is_error(r36) goto L51 (error at to_bytes:32) else goto L32 +L32: + r37 = builtins :: module + r38 = 'hex' + r39 = CPyObject_GetAttr(r37, r38) + if is_error(r39) goto L53 (error at to_bytes:32) else goto L33 +L33: + r40 = box(int, r36) + r41 = [r40] + r42 = load_address r41 + r43 = PyObject_Vectorcall(r39, r42, 1, 0) + dec_ref r39 + if is_error(r43) goto L54 (error at to_bytes:32) else goto L34 +L34: + dec_ref r40 + r44 = cast(str, r43) + if is_error(r44) goto L51 (error at to_bytes:32) else goto L35 +L35: + r45 = to_bytes(r44) + dec_ref r44 + if is_error(r45) goto L51 (error at to_bytes:32) else goto L36 +L36: + return r45 +L37: + r46 = builtins :: module + r47 = 'memoryview' + r48 = CPyObject_GetAttr(r46, r47) + if is_error(r48) goto L51 (error at to_bytes:33) else goto L38 +L38: + r49 = PyObject_IsInstance(val, r48) + dec_ref r48 + r50 = r49 >= 0 :: signed + if not r50 goto L51 (error at to_bytes:33) else goto L39 :: bool +L39: + r51 = truncate r49: i32 to builtins.bool + if r51 goto L40 else goto L43 :: bool +L40: + r52 = load_address PyBytes_Type + r53 = [val] + r54 = load_address r53 + r55 = PyObject_Vectorcall(r52, r54, 1, 0) + if is_error(r55) goto L51 (error at to_bytes:34) else goto L41 +L41: + r56 = cast(bytes, r55) + if is_error(r56) goto L51 (error at to_bytes:34) else goto L42 +L42: + return r56 +L43: + r57 = '' + r58 = 'Cannot convert ' + r59 = '{!r:{}}' + r60 = '' + r61 = 'format' + r62 = [r59, val, r60] + r63 = load_address r62 + r64 = PyObject_VectorcallMethod(r61, r63, 9223372036854775811, 0) + if is_error(r64) goto L51 (error at to_bytes:36) else goto L44 +L44: + r65 = ' of type ' + r66 = '{:{}}' + r67 = CPy_TYPE(val) + r68 = '' + r69 = 'format' + r70 = [r66, r67, r68] + r71 = load_address r70 + r72 = PyObject_VectorcallMethod(r69, r71, 9223372036854775811, 0) + if is_error(r72) goto L55 (error at to_bytes:36) else goto L45 +L45: + dec_ref r67 + r73 = ' to bytes' + r74 = PyList_New(5) + if is_error(r74) goto L56 (error at to_bytes:36) else goto L46 +L46: + r75 = get_element_ptr r74 ob_item :: PyListObject + r76 = load_mem r75 :: ptr* + inc_ref r58 + set_mem r76, r58 :: builtins.object* + r77 = r76 + 8 + set_mem r77, r64 :: builtins.object* + inc_ref r65 + r78 = r76 + 16 + set_mem r78, r65 :: builtins.object* + r79 = r76 + 24 + set_mem r79, r72 :: builtins.object* + inc_ref r73 + r80 = r76 + 32 + set_mem r80, r73 :: builtins.object* + r81 = PyUnicode_Join(r57, r74) + dec_ref r74 + if is_error(r81) goto L51 (error at to_bytes:36) else goto L47 +L47: + r82 = builtins :: module + r83 = 'TypeError' + r84 = CPyObject_GetAttr(r82, r83) + if is_error(r84) goto L57 (error at to_bytes:36) else goto L48 +L48: + r85 = [r81] + r86 = load_address r85 + r87 = PyObject_Vectorcall(r84, r86, 1, 0) + dec_ref r84 + if is_error(r87) goto L57 (error at to_bytes:36) else goto L49 +L49: + dec_ref r81 + CPy_Raise(r87) + dec_ref r87 + if not 0 goto L51 (error at to_bytes:36) else goto L50 :: bool +L50: + unreachable +L51: + r88 = :: bytes + return r88 +L52: + dec_ref r29 + goto L51 +L53: + dec_ref r36 :: int + goto L51 +L54: + dec_ref r40 + goto L51 +L55: + dec_ref r64 + dec_ref r67 + goto L51 +L56: + dec_ref r64 + dec_ref r72 + goto L51 +L57: + dec_ref r81 + goto L51 + +def hexstr_to_bytes(hexstr): + hexstr, r0, r1 :: str + r2 :: tuple[str, str] + r3 :: object + r4 :: bool + r5 :: object + r6, non_prefixed_hex :: str + r7 :: native_int + r8 :: bit + r9 :: short_int + r10 :: int + r11 :: bit + r12, r13, padded_hex :: str + r14 :: bytes + r15 :: tuple[object, object, object] + r16 :: object + r17 :: str + r18 :: object + r19 :: bit + r20, r21, r22 :: str + r23 :: object + r24 :: str + r25 :: object + r26 :: object[1] + r27 :: object_ptr + r28 :: object + r29 :: bit + r30 :: object + r31 :: bool + r32 :: object[1] + r33 :: object_ptr + r34 :: object + r35, r36 :: bytes +L0: + r0 = '0x' + r1 = '0X' + inc_ref r0 + inc_ref r1 + r2 = (r0, r1) + r3 = box(tuple[str, str], r2) + r4 = CPyStr_Startswith(hexstr, r3) + dec_ref r3 + if is_error(r4) goto L31 (error at hexstr_to_bytes:40) else goto L1 +L1: + if r4 goto L2 else goto L5 :: bool +L2: + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 +L3: + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 +L4: + non_prefixed_hex = r6 + goto L6 +L5: + inc_ref hexstr + non_prefixed_hex = hexstr +L6: + r7 = CPyStr_Size_size_t(hexstr) + r8 = r7 >= 0 :: signed + if not r8 goto L32 (error at hexstr_to_bytes:46) else goto L7 :: bool +L7: + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 +L8: + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool +L9: + r12 = '0' + r13 = PyUnicode_Concat(r12, non_prefixed_hex) + dec_ref non_prefixed_hex + if is_error(r13) goto L31 (error at hexstr_to_bytes:47) else goto L10 +L10: + padded_hex = r13 + goto L12 +L11: + padded_hex = non_prefixed_hex +L12: + r14 = PyUnicode_AsASCIIString(padded_hex) + if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 +L13: + goto L25 +L14: + r15 = CPy_CatchError() + r16 = builtins :: module + r17 = 'UnicodeDecodeError' + r18 = CPyObject_GetAttr(r16, r17) + if is_error(r18) goto L34 (error at hexstr_to_bytes:53) else goto L15 +L15: + r19 = CPy_ExceptionMatches(r18) + dec_ref r18 + if r19 goto L16 else goto L35 :: bool +L16: + r20 = 'hex string ' + r21 = ' may only contain [0-9a-fA-F] characters' + r22 = CPyStr_Build(3, r20, padded_hex, r21) + dec_ref padded_hex + if is_error(r22) goto L23 (error at hexstr_to_bytes:55) else goto L17 +L17: + r23 = builtins :: module + r24 = 'ValueError' + r25 = CPyObject_GetAttr(r23, r24) + if is_error(r25) goto L36 (error at hexstr_to_bytes:54) else goto L18 +L18: + r26 = [r22] + r27 = load_address r26 + r28 = PyObject_Vectorcall(r25, r27, 1, 0) + dec_ref r25 + if is_error(r28) goto L36 (error at hexstr_to_bytes:54) else goto L19 +L19: + dec_ref r22 + CPy_Raise(r28) + dec_ref r28 + if not 0 goto L23 (error at hexstr_to_bytes:54) else goto L37 :: bool +L20: + unreachable +L21: + CPy_Reraise() + if not 0 goto L23 else goto L38 :: bool +L22: + unreachable +L23: + CPy_RestoreExcInfo(r15) + dec_ref r15 + r29 = CPy_KeepPropagating() + if not r29 goto L31 else goto L24 :: bool +L24: + unreachable +L25: + r30 = faster_hexbytes._utils.unhexlify :: static + if is_error(r30) goto L39 else goto L28 +L26: + r31 = raise NameError('value for final name "unhexlify" was not set') + if not r31 goto L31 (error at hexstr_to_bytes:58) else goto L27 :: bool +L27: + unreachable +L28: + r32 = [r14] + r33 = load_address r32 + r34 = PyObject_Vectorcall(r30, r33, 1, 0) + if is_error(r34) goto L40 (error at hexstr_to_bytes:58) else goto L29 +L29: + dec_ref r14 + r35 = cast(bytes, r34) + if is_error(r35) goto L31 (error at hexstr_to_bytes:58) else goto L30 +L30: + return r35 +L31: + r36 = :: bytes + return r36 +L32: + dec_ref non_prefixed_hex + goto L31 +L33: + dec_ref padded_hex + goto L13 +L34: + dec_ref padded_hex + goto L23 +L35: + dec_ref padded_hex + goto L21 +L36: + dec_ref r22 + goto L23 +L37: + dec_ref r15 + goto L20 +L38: + dec_ref r15 + goto L22 +L39: + dec_ref r14 + goto L26 +L40: + dec_ref r14 + goto L31 + +def __top_level__(): + r0, r1 :: object + r2 :: bit + r3 :: str + r4 :: object + r5 :: object_ptr + r6 :: object_ptr[1] + r7 :: c_ptr + r8 :: native_int[1] + r9 :: c_ptr + r10 :: object + r11 :: dict + r12, r13 :: str + r14 :: bit + r15 :: object + r16 :: str + r17 :: dict + r18, r19 :: object + r20 :: str + r21 :: object + r22 :: dict + r23 :: str + r24 :: i32 + r25 :: bit + r26 :: None +L0: + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool +L1: + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L8 (error at :-1) else goto L2 +L2: + builtins = r4 :: module + dec_ref r4 +L3: + r5 = load_address binascii :: module + r6 = [r5] + r7 = load_address r6 + r8 = [1] + r9 = load_address r8 + r10 = (('binascii', 'binascii', 'binascii'),) + r11 = faster_hexbytes._utils.globals :: static + r12 = 'faster_hexbytes/_utils.py' + r13 = '' + r14 = CPyImport_ImportMany(r10, r7, r11, r12, r13, r9) + if not r14 goto L8 else goto L4 :: bool +L4: + r15 = ('Final', 'Union') + r16 = 'typing' + r17 = faster_hexbytes._utils.globals :: static + r18 = CPyImport_ImportFromMany(r16, r15, r15, r17) + if is_error(r18) goto L8 (error at :2) else goto L5 +L5: + typing = r18 :: module + dec_ref r18 + r19 = binascii :: module + r20 = 'unhexlify' + r21 = CPyObject_GetAttr(r19, r20) + if is_error(r21) goto L8 (error at :8) else goto L6 +L6: + faster_hexbytes._utils.unhexlify = r21 :: static + r22 = faster_hexbytes._utils.globals :: static + r23 = 'unhexlify' + r24 = CPyDict_SetItem(r22, r23, r21) + dec_ref r21 + r25 = r24 >= 0 :: signed + if not r25 goto L8 (error at :8) else goto L7 :: bool +L7: + return 1 +L8: + r26 = :: None + return r26 diff --git a/hexbytes/__init__.py b/faster_hexbytes/__init__.py similarity index 79% rename from hexbytes/__init__.py rename to faster_hexbytes/__init__.py index bf32717..dbacf8e 100644 --- a/hexbytes/__init__.py +++ b/faster_hexbytes/__init__.py @@ -2,7 +2,7 @@ version as __version, ) -from .main import ( +from faster_hexbytes.main import ( HexBytes, ) diff --git a/hexbytes/_utils.py b/faster_hexbytes/_utils.py similarity index 86% rename from hexbytes/_utils.py rename to faster_hexbytes/_utils.py index 5551728..baa1f95 100644 --- a/hexbytes/_utils.py +++ b/faster_hexbytes/_utils.py @@ -1,12 +1,16 @@ import binascii from typing import ( + Final, Union, ) -def to_bytes(val: Union[bool, bytearray, bytes, int, str, memoryview]) -> bytes: +unhexlify: Final = binascii.unhexlify + + +def to_bytes(val: Union[bytes, str, bytearray, bool, int, memoryview]) -> bytes: """ - Equivalent to: `eth_utils.hexstr_if_str(eth_utils.to_bytes, val)` . + Equivalent to: `faster_eth_utils.hexstr_if_str(faster_eth_utils.to_bytes, val)` . Convert a hex string, integer, or bool, to a bytes representation. Alternatively, pass through bytes or bytearray as a bytes value. @@ -51,4 +55,4 @@ def hexstr_to_bytes(hexstr: str) -> bytes: f"hex string {padded_hex} may only contain [0-9a-fA-F] characters" ) else: - return binascii.unhexlify(ascii_hex) + return unhexlify(ascii_hex) diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py new file mode 100644 index 0000000..774cd23 --- /dev/null +++ b/faster_hexbytes/main.py @@ -0,0 +1,101 @@ +from typing import ( + TYPE_CHECKING, + Callable, + Final, + Tuple, + Type, + Union, + overload, +) + +# accessing hexbytes.HexBytes after `import hexbytes` +# fails because mypyc tries to lookup HexBytes from +# CPyModule_hexbytes___main which was never imported +import hexbytes.main as hexbytes +from mypy_extensions import ( + mypyc_attr, +) +from typing_extensions import ( + Self, +) + +from faster_hexbytes._utils import ( + to_bytes, +) + +if TYPE_CHECKING: + from typing import ( + SupportsIndex, + ) + + +BytesLike = Union[bytes, str, bool, bytearray, int, memoryview] + +_bytes_new: Final = bytes.__new__ + + +@mypyc_attr(native_class=False, allow_interpreted_subclasses=True) +class HexBytes(hexbytes.HexBytes): + """ + Thin wrapper around the python built-in :class:`bytes` class. + + It has these changes: + 1. Accepts more initializing values: bool, bytearray, bytes, (non-negative) int, + str, and memoryview + 2. The representation at console (__repr__) is 0x-prefixed + 3. ``to_0x_hex`` returns a 0x-prefixed hex string + """ + + def __new__(cls, val: BytesLike) -> Self: + bytesval = to_bytes(val) + return _bytes_new(cls, bytesval) + + @overload + def __getitem__(self, key: "SupportsIndex") -> int: # noqa: F811 + ... + + @overload # noqa: F811 + def __getitem__(self, key: slice) -> Self: # noqa: F811 + ... + + def __getitem__( # noqa: F811 + self, key: Union["SupportsIndex", slice] + ) -> Union[int, Self]: + result = bytes.__getitem__(self, key) + if isinstance(result, int): + return result + cls = type(self) + if cls is HexBytes: + # fast-path case with faster C code for non-subclass + return HexBytes(result) # type: ignore [return-value] + return cls(result) + + def __repr__(self) -> str: + return f"HexBytes('0x{self.hex()}')" + + def to_0x_hex(self) -> str: + """ + Convert the bytes to a 0x-prefixed hex string + """ + return f"0x{self.hex()}" + + def __reduce__( + self, + ) -> Tuple[Callable[..., bytes], Tuple[Type["HexBytes"], bytes]]: + """ + An optimized ``__reduce__`` that bypasses the input validation in + ``HexBytes.__new__`` since an existing HexBytes instance has already been + validated when created. + """ + return _bytes_new, (type(self), bytes(self)) + + +# these 3 helpers serve as a workaround for a mypyc bug until +# https://github.com/python/mypy/pull/19957 is merged and released + +@mypyc_attr(native_class=False) +class _HexBytesSubclass1(HexBytes): ... +@mypyc_attr(native_class=False) +class _HexBytesSubclass2(HexBytes): ... +@mypyc_attr(native_class=False) +class _HexBytesSubclass3(HexBytes): ... diff --git a/faster_hexbytes/py.typed b/faster_hexbytes/py.typed new file mode 100644 index 0000000..d3f5a12 --- /dev/null +++ b/faster_hexbytes/py.typed @@ -0,0 +1 @@ + diff --git a/hexbytes/main.py b/hexbytes/main.py deleted file mode 100644 index ca24783..0000000 --- a/hexbytes/main.py +++ /dev/null @@ -1,72 +0,0 @@ -from typing import ( - TYPE_CHECKING, - Callable, - Tuple, - Type, - Union, - cast, - overload, -) - -from ._utils import ( - to_bytes, -) - -if TYPE_CHECKING: - from typing import ( - SupportsIndex, - ) - -BytesLike = Union[bool, bytearray, bytes, int, str, memoryview] - - -class HexBytes(bytes): - """ - Thin wrapper around the python built-in :class:`bytes` class. - - It has these changes: - 1. Accepts more initializing values: bool, bytearray, bytes, (non-negative) int, - str, and memoryview - 2. The representation at console (__repr__) is 0x-prefixed - 3. ``to_0x_hex`` returns a 0x-prefixed hex string - """ - - def __new__(cls: Type[bytes], val: BytesLike) -> "HexBytes": - bytesval = to_bytes(val) - return cast(HexBytes, super().__new__(cls, bytesval)) # type: ignore # https://github.com/python/typeshed/issues/2630 # noqa: E501 - - @overload - def __getitem__(self, key: "SupportsIndex") -> int: # noqa: F811 - ... - - @overload # noqa: F811 - def __getitem__(self, key: slice) -> "HexBytes": # noqa: F811 - ... - - def __getitem__( # noqa: F811 - self, key: Union["SupportsIndex", slice] - ) -> Union[int, bytes, "HexBytes"]: - result = super().__getitem__(key) - if hasattr(result, "hex"): - return type(self)(result) - else: - return result - - def __repr__(self) -> str: - return f"HexBytes({'0x' + self.hex()!r})" - - def to_0x_hex(self) -> str: - """ - Convert the bytes to a 0x-prefixed hex string - """ - return "0x" + self.hex() - - def __reduce__( - self, - ) -> Tuple[Callable[..., bytes], Tuple[Type["HexBytes"], bytes]]: - """ - An optimized ``__reduce__`` that bypasses the input validation in - ``HexBytes.__new__`` since an existing HexBytes instance has already been - validated when created. - """ - return bytes.__new__, (type(self), bytes(self)) diff --git a/hexbytes/py.typed b/hexbytes/py.typed deleted file mode 100644 index e69de29..0000000 diff --git a/pyproject.toml b/pyproject.toml index 080d07c..0515243 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,3 +1,7 @@ +[build-system] +requires = ["setuptools", "wheel", "mypy[mypyc]==1.18.2", "hexbytes==1.3.1"] +build-backend = "setuptools.build_meta" + [tool.autoflake] exclude = "__init__.py" remove_all_unused_imports = true diff --git a/scripts/benchmark/compare_benchmark_results.py b/scripts/benchmark/compare_benchmark_results.py new file mode 100644 index 0000000..fbb9f2f --- /dev/null +++ b/scripts/benchmark/compare_benchmark_results.py @@ -0,0 +1,98 @@ +""" +compare_benchmark_results.py + +Compares the two implementations in each benchmark group from a pytest-benchmark parsed results JSON file, +grouped by submodule. +For each submodule and group (e.g., "abi_to_signature"), finds both implementations +(e.g., "test_abi_to_signature" and "test_faster_abi_to_signature"), computes the percent change +in mean execution time, speedup percent, and x factor, and writes a diff JSON file summarizing the results. + +Usage: + python compare_benchmark_results.py [output.json] +""" + +import json +import sys +import re +from typing import Any, Dict + + +def get_group_name(test_name: str) -> str: + # Extract group from test name, e.g., test_foo, test_faster_foo -> group: foo + m = re.match(r"test_faster_(.+)", test_name) + if m: + return m.group(1) + m = re.match(r"test_(.+)", test_name) + if m: + return m.group(1) + return test_name + + +def compare_group(group_results: Dict[str, Any]) -> Dict[str, Any]: + # Find reference and faster implementations in the group + ref = None + fast = None + ref_name = None + fast_name = None + for func_name, data in group_results.items(): + if func_name.startswith("test_faster_"): + fast = data + fast_name = func_name + elif func_name.startswith("test_"): + ref = data + ref_name = func_name + + if ref and fast: + mean_ref = ref["mean"] + mean_fast = fast["mean"] + percent_change = ( + ((mean_ref - mean_fast) / mean_ref) * 100 if mean_ref != 0 else 0.0 + ) + speedup_x = mean_ref / mean_fast if mean_fast != 0 else float("inf") + speedup_percent = ( + (speedup_x - 1) * 100 if speedup_x != float("inf") else float("inf") + ) + return { + "reference_mean": mean_ref, + "faster_mean": mean_fast, + "percent_change": percent_change, + "speedup_percent": speedup_percent, + "speedup_x": speedup_x, + "reference": ref_name, + "faster": fast_name, + } + else: + missing = [] + if not ref: + missing.append("reference") + if not fast: + missing.append("faster") + return {"note": f"Missing implementation(s): {missing}"} + + +def main() -> None: + if len(sys.argv) < 2: + print("Usage: python compare_benchmark_results.py [output.json]") + sys.exit(1) + results_path = sys.argv[1] + output_path = sys.argv[2] if len(sys.argv) > 2 else "benchmark_diff.json" + + with open(results_path, "r") as f: + results = json.load(f) + + # results: {submodule: {group: {function_name: {...}}}} + diff_by_submodule = { + submodule: { + group: compare_group(group_results) + for group, group_results in groups.items() + } + for submodule, groups in results.items() + } + + with open(output_path, "w") as f: + json.dump(diff_by_submodule, f, indent=2) + print(f"Diff written to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/scripts/benchmark/generate_benchmark_markdown.py b/scripts/benchmark/generate_benchmark_markdown.py new file mode 100644 index 0000000..ea79168 --- /dev/null +++ b/scripts/benchmark/generate_benchmark_markdown.py @@ -0,0 +1,85 @@ +import os +import json + + +def main(): + diff_path = "pytest_benchmark_diff.json" + results_dir = os.path.join("benchmarks", "results") + os.makedirs(results_dir, exist_ok=True) + + # Get repo and branch info from environment variables (for links) + repo = os.environ.get("GITHUB_REPOSITORY", "unknown/unknown") + branch = os.environ.get("GITHUB_HEAD_REF") or os.environ.get( + "GITHUB_REF", "main" + ).replace("refs/heads/", "") + + with open(diff_path, "r", encoding="utf-8") as f: + diff = json.load(f) + + for submodule, groupDiffs in diff.items(): + # Convert submodule name to submodule file path (e.g., faster_hexbytes.main -> faster_hexbytes/main.py) + submoduleFile = "unknown" + benchmarkFile = "unknown" + m = None + if submodule.startswith("faster_hexbytes."): + m = submodule[len("faster_hexbytes.") :] + + if m: + submoduleFile = f"faster_hexbytes/{m}.py" + benchmarkFile = f"benchmarks/test_{m}_benchmarks.py" + + submoduleUrl = f"https://github.com/{repo}/blob/{branch}/{submoduleFile}" + benchmarkUrl = f"https://github.com/{repo}/blob/{branch}/{benchmarkFile}" + + md_lines = [] + md_lines.append( + f"#### [{submodule}]({submoduleUrl}) - [view benchmarks]({benchmarkUrl})\n" + ) + md_lines.append( + "| Function | Reference Mean | Faster Mean | % Change | Speedup (%) | x Faster | Faster |" + ) + md_lines.append( + "|----------|---------------|-------------|----------|-------------|----------|--------|" + ) + + for group, data in sorted(groupDiffs.items()): + if data.get("percent_change") is not None: + emoji = "➖" + if data["percent_change"] > 0: + emoji = "✅" + elif data["percent_change"] < 0: + emoji = "❌" + percentChange = ( + f"{data['percent_change']:.2f}%" + if data.get("percent_change") is not None + else "" + ) + speedupPercent = ( + f"{data['speedup_percent']:.2f}%" + if data.get("speedup_percent") is not None + else "" + ) + speedupX = ( + f"{data['speedup_x']:.2f}x" + if data.get("speedup_x") is not None + and isinstance(data["speedup_x"], (int, float)) + else "" + ) + md_lines.append( + f"| `{group}` | {data.get('reference_mean', '')} | {data.get('faster_mean', '')} | {percentChange} | {speedupPercent} | {speedupX} | {emoji} |" + ) + elif data.get("note"): + md_lines.append(f"| `{group}` | | | | | | ➖ |") + + md_lines.append("") # Blank line at end + md_content = "\n".join(md_lines) + + # Write to file + module_name = submodule.split(".")[-1] + out_path = os.path.join(results_dir, f"{module_name}.md") + with open(out_path, "w", encoding="utf-8") as outf: + outf.write(md_content) + + +if __name__ == "__main__": + main() diff --git a/scripts/benchmark/parse_benchmark_output.py b/scripts/benchmark/parse_benchmark_output.py new file mode 100644 index 0000000..bcf1ba9 --- /dev/null +++ b/scripts/benchmark/parse_benchmark_output.py @@ -0,0 +1,78 @@ +""" +parse_benchmark_output.py + +Extracts per-function benchmark timings from pytest-benchmark's benchmark.json output. +Parses the JSON file, finds all test function results, and writes a JSON file +mapping submodules (e.g., Python submodules like faster_hexbytes.main) to groups and their test functions and results. + +Usage: + python parse_benchmark_output.py [output.json] +""" + +import json +import sys +import re +from collections import defaultdict +from typing import Dict, Any + + +def get_submodule(bench: dict) -> str: + # Extract Python submodule from fullname, e.g., "benchmarks/test_abi_benchmarks.py::test_abi_to_signature" + fullname = bench.get("fullname", "") + # Try to extract the submodule from the test file path + m = re.search(r"benchmarks/test_([a-zA-Z0-9_]+)_benchmarks\.py", fullname) + if m: + return f"faster_hexbytes.{m.group(1)}" + return "unknown" + + +def get_group_name(test_name: str) -> str: + # Extract group from test name, e.g., test_foo, test_faster_foo -> group: foo + m = re.match(r"test_faster_(.+)", test_name) + if m: + return m.group(1) + m = re.match(r"test_(.+)", test_name) + if m: + return m.group(1) + return test_name + + +def parse_pytest_benchmark_json(data: dict) -> Dict[str, Dict[str, Dict[str, Any]]]: + """ + Parses pytest-benchmark's benchmark.json and extracts per-function timings, + grouped by submodule and group name. + Returns a dict: {submodule: {group: {function_name: {...}}}} + """ + results = defaultdict(lambda: defaultdict(dict)) + for bench in data.get("benchmarks", []): + name = bench["name"] + submodule = get_submodule(bench) + group = get_group_name(name) + stats = bench["stats"] + results[submodule][group][name] = { + "mean": stats.get("mean"), + "stddev": stats.get("stddev", None), + "iqr": stats.get("iqr", None), + "min": stats.get("min", None), + "max": stats.get("max", None), + "rounds": stats.get("rounds", None), + } + return results + + +def main() -> None: + if len(sys.argv) < 2: + print("Usage: python parse_benchmark_output.py [output.json]") + sys.exit(1) + infile = sys.argv[1] + outfile = sys.argv[2] if len(sys.argv) > 2 else "benchmark_results.json" + with open(infile, "r") as f: + data = json.load(f) + results = parse_pytest_benchmark_json(data) + with open(outfile, "w") as f: + json.dump(results, f, indent=2) + print(f"Parsed results written to {outfile}") + + +if __name__ == "__main__": + main() diff --git a/setup.py b/setup.py index 0028d8f..11dc299 100644 --- a/setup.py +++ b/setup.py @@ -1,8 +1,14 @@ #!/usr/bin/env python +import sys from setuptools import ( find_packages, setup, ) +from mypyc.build import mypycify + + +version = "1.3.2" +hexbytes_version = "1.3.1" extras_require = { "dev": [ @@ -38,26 +44,43 @@ long_description = readme.read() +if sys.version_info >= (3, 9): + ext_modules = mypycify(["faster_hexbytes/", "--strict", "--pretty"]) +else: + # we can't compile on python3.8 but we can still let the user install + ext_modules = [] + + setup( - name="hexbytes", + name="faster_hexbytes", # *IMPORTANT*: Don't manually change the version here. See Contributing docs for the release process. - version="1.3.1", - description="""hexbytes: Python `bytes` subclass that decodes hex, with a readable console output""", + version=version, + description="""A faster fork of hexbytes: Python `bytes` subclass that decodes hex, with a readable console output. Implemented in C.""", long_description=long_description, long_description_content_type="text/markdown", author="The Ethereum Foundation", author_email="snakecharmers@ethereum.org", url="https://github.com/ethereum/hexbytes", include_package_data=True, - install_requires=[], - python_requires=">=3.8, <4", + install_requires=[f"hexbytes=={hexbytes_version}", "mypy_extensions"], + python_requires=">=3.9, <4", extras_require=extras_require, - py_modules=["hexbytes"], + py_modules=["faster_hexbytes"], license="MIT", zip_safe=False, keywords="ethereum", - packages=find_packages(exclude=["scripts", "scripts.*", "tests", "tests.*"]), - package_data={"hexbytes": ["py.typed"]}, + packages=find_packages( + exclude=[ + "scripts", + "scripts.*", + "tests", + "tests.*", + "benchmarks", + "benchmarks.*", + ] + ), + ext_modules=ext_modules, + package_data={"faster_hexbytes": ["py.typed"]}, classifiers=[ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", @@ -70,5 +93,6 @@ "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", ], ) diff --git a/tests/core/test_hexbytes.py b/tests/core/test_hexbytes.py index 3da3c39..9a196ea 100644 --- a/tests/core/test_hexbytes.py +++ b/tests/core/test_hexbytes.py @@ -11,7 +11,7 @@ strategies as st, ) -from hexbytes import ( +from faster_hexbytes import ( HexBytes, ) diff --git a/tests/core/test_import_and_version.py b/tests/core/test_import_and_version.py index 6807263..55418fe 100644 --- a/tests/core/test_import_and_version.py +++ b/tests/core/test_import_and_version.py @@ -1,4 +1,4 @@ def test_import_and_version(): - import hexbytes + import faster_hexbytes - assert isinstance(hexbytes.__version__, str) + assert isinstance(faster_hexbytes.__version__, str) diff --git a/tox.ini b/tox.ini index e8fd0a8..cfb884f 100644 --- a/tox.ini +++ b/tox.ini @@ -1,8 +1,8 @@ [tox] envlist= - py{38,39,310,311,312,313}-core - py{38,39,310,311,312,313}-lint - py{38,39,310,311,312,313}-wheel + py{39,310,311,312,313,314}-core + py{39,310,311,312,313,314}-lint + py{39,310,311,312,313,314}-wheel windows-wheel docs @@ -23,25 +23,25 @@ commands= basepython= docs: python windows-wheel: python - py38: python3.8 py39: python3.9 py310: python3.10 py311: python3.11 py312: python3.12 py313: python3.13 + py314: python3.14 extras= test docs allowlist_externals=make,pre-commit -[testenv:py{38,39,310,311,312,313}-lint] +[testenv:py{39,310,311,312,313,314}-lint] deps=pre-commit extras=dev commands= pre-commit install pre-commit run --all-files --show-diff-on-failure -[testenv:py{38,39,310,311,312,313}-wheel] +[testenv:py{39,310,311,312,313,314}-wheel] deps= wheel build[virtualenv]