From 4ac65ff0ee72177243a3e8b04270161145cbd205 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:00:06 -0400 Subject: [PATCH 01/70] chore: add build deps --- pyproject.toml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 080d07c..2edc694 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,3 +1,7 @@ +[build-system] +requires = ["setuptools", "wheel", "mypy[mypyc]>=1.14.1,<1.18.3"] +build-backend = "setuptools.build_meta" + [tool.autoflake] exclude = "__init__.py" remove_all_unused_imports = true From acce3fc05c84bcd3588a2a7c335f2a4dfa343350 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:03:55 -0400 Subject: [PATCH 02/70] Update setup.py --- setup.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/setup.py b/setup.py index 0028d8f..04fc12b 100644 --- a/setup.py +++ b/setup.py @@ -3,6 +3,7 @@ find_packages, setup, ) +from mypyc.build import mypycify extras_require = { "dev": [ @@ -38,11 +39,17 @@ 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""", + 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", @@ -52,12 +59,13 @@ install_requires=[], python_requires=">=3.8, <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"]}, + ext_modules=ext_modules, + package_data={"faster_hexbytes": ["py.typed"]}, classifiers=[ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", @@ -70,5 +78,6 @@ "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", ], ) From 95741981e7e0fdf2269bfb1c00a958da87c8888a Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:04:45 -0400 Subject: [PATCH 03/70] Rename __init__.py to __init__.py --- {hexbytes => faster_hexbytes}/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {hexbytes => faster_hexbytes}/__init__.py (100%) diff --git a/hexbytes/__init__.py b/faster_hexbytes/__init__.py similarity index 100% rename from hexbytes/__init__.py rename to faster_hexbytes/__init__.py From c746be49665cf24e4172148909e63561ab1c6265 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:05:07 -0400 Subject: [PATCH 04/70] Rename main.py to main.py --- {hexbytes => faster_hexbytes}/main.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {hexbytes => faster_hexbytes}/main.py (100%) diff --git a/hexbytes/main.py b/faster_hexbytes/main.py similarity index 100% rename from hexbytes/main.py rename to faster_hexbytes/main.py From f9ca755fe2f497b17b946e67926b2736fee00658 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:05:25 -0400 Subject: [PATCH 05/70] Rename _utils.py to _utils.py --- {hexbytes => faster_hexbytes}/_utils.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {hexbytes => faster_hexbytes}/_utils.py (100%) diff --git a/hexbytes/_utils.py b/faster_hexbytes/_utils.py similarity index 100% rename from hexbytes/_utils.py rename to faster_hexbytes/_utils.py From 908ec37bb036fdf49125d8f14aab94a7536668e7 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:05:40 -0400 Subject: [PATCH 06/70] Rename py.typed to py.typed --- faster_hexbytes/py.typed | 1 + hexbytes/py.typed | 0 2 files changed, 1 insertion(+) create mode 100644 faster_hexbytes/py.typed delete mode 100644 hexbytes/py.typed 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/py.typed b/hexbytes/py.typed deleted file mode 100644 index e69de29..0000000 From 77d2094a839d2700adc638f828e8e2050b0e798f Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:06:11 -0400 Subject: [PATCH 07/70] Update test_hexbytes.py --- tests/core/test_hexbytes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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, ) From fcac0b10c93668c6facb81c668cd2c159997fb30 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:06:24 -0400 Subject: [PATCH 08/70] Update test_import_and_version.py --- tests/core/test_import_and_version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/core/test_import_and_version.py b/tests/core/test_import_and_version.py index 6807263..84b61da 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) From 390c77c5bbad6f912efe8ae2729aef9a1f6c7ec0 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:08:47 -0400 Subject: [PATCH 09/70] Create compile.yaml --- .github/workflows/compile.yaml | 47 ++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 .github/workflows/compile.yaml diff --git a/.github/workflows/compile.yaml b/.github/workflows/compile.yaml new file mode 100644 index 0000000..dcda9f6 --- /dev/null +++ b/.github/workflows/compile.yaml @@ -0,0 +1,47 @@ +name: Compile + +on: + pull_request: + branches: + - master + +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: 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 From 351021850c4ea35ee3f5aed1ead835f6625ae205 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:09:58 -0400 Subject: [PATCH 10/70] Update compile.yaml --- .github/workflows/compile.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/compile.yaml b/.github/workflows/compile.yaml index dcda9f6..71baa09 100644 --- a/.github/workflows/compile.yaml +++ b/.github/workflows/compile.yaml @@ -4,6 +4,9 @@ on: pull_request: branches: - master + push: + branches: + - master concurrency: group: ${{ github.workflow }}-${{ github.ref }} From 648d247b60ebcfc3c638b3d82532fb64d964c69a Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:11:41 -0400 Subject: [PATCH 11/70] Update setup.py --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index 04fc12b..83cea33 100644 --- a/setup.py +++ b/setup.py @@ -1,4 +1,5 @@ #!/usr/bin/env python +import sys from setuptools import ( find_packages, setup, From f31d06c487af70c445d8911383f080a08f836e28 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:14:03 -0400 Subject: [PATCH 12/70] Update main.py --- faster_hexbytes/main.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index ca24783..fa25a61 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -8,6 +8,13 @@ overload, ) +from mypy_extensions import ( + mypyc_attr, +) +from typing_extensions import ( + Self, +) + from ._utils import ( to_bytes, ) @@ -20,6 +27,7 @@ BytesLike = Union[bool, bytearray, bytes, int, str, memoryview] +@mypy_extensions.mypyc_attr(native_class=False) class HexBytes(bytes): """ Thin wrapper around the python built-in :class:`bytes` class. @@ -31,9 +39,9 @@ class HexBytes(bytes): 3. ``to_0x_hex`` returns a 0x-prefixed hex string """ - def __new__(cls: Type[bytes], val: BytesLike) -> "HexBytes": + def __new__(cls, val: BytesLike) -> Self: bytesval = to_bytes(val) - return cast(HexBytes, super().__new__(cls, bytesval)) # type: ignore # https://github.com/python/typeshed/issues/2630 # noqa: E501 + return super().__new__(cls, bytesval) @overload def __getitem__(self, key: "SupportsIndex") -> int: # noqa: F811 From 8adfdc2a5d47b3e5ee9716df552d496695e6fab7 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:14:22 -0400 Subject: [PATCH 13/70] Update main.py --- faster_hexbytes/main.py | 1 - 1 file changed, 1 deletion(-) diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index fa25a61..8efcf9d 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -4,7 +4,6 @@ Tuple, Type, Union, - cast, overload, ) From b749aa54a0a10f4316851dac22c1089ca8b5b0d8 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:15:26 -0400 Subject: [PATCH 14/70] Update main.py --- faster_hexbytes/main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index 8efcf9d..a91ce49 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -26,7 +26,7 @@ BytesLike = Union[bool, bytearray, bytes, int, str, memoryview] -@mypy_extensions.mypyc_attr(native_class=False) +@mypyc_attr(native_class=False) class HexBytes(bytes): """ Thin wrapper around the python built-in :class:`bytes` class. From d5aa75800c333d2d8278434bdaa12a74e27e3286 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:17:48 -0400 Subject: [PATCH 15/70] Update main.py --- faster_hexbytes/main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index a91ce49..b987a6c 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -40,7 +40,7 @@ class HexBytes(bytes): def __new__(cls, val: BytesLike) -> Self: bytesval = to_bytes(val) - return super().__new__(cls, bytesval) + return bytes.__new__(cls, bytesval) @overload def __getitem__(self, key: "SupportsIndex") -> int: # noqa: F811 From 28398268ded846b8443cfcfd31db6b8fdc0fa79c Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Mon, 29 Sep 2025 22:20:34 -0400 Subject: [PATCH 16/70] Update .gitignore --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 2eb3d43..c3a466e 100644 --- a/.gitignore +++ b/.gitignore @@ -7,7 +7,8 @@ *.egg *.egg-info dist -build +build/**/*.py +build/**/*.typed .build eggs .eggs From 512b58c537f8228dc2be1b82b39206ca77c2e4ba Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 02:20:55 +0000 Subject: [PATCH 17/70] chore: compile C files for source control --- build/__native_6a32f4913d613d6a7ddf.c | 2975 +++++++++++++++++ build/__native_6a32f4913d613d6a7ddf.h | 72 + .../__native_internal_6a32f4913d613d6a7ddf.h | 75 + build/faster_hexbytes.c | 21 + build/faster_hexbytes/_utils.c | 21 + build/faster_hexbytes/main.c | 21 + build/ops.txt | 1375 ++++++++ .../build/__native_6a32f4913d613d6a7ddf.o | Bin 0 -> 342400 bytes .../build/faster_hexbytes.o | Bin 0 -> 5296 bytes .../build/faster_hexbytes/_utils.o | Bin 0 -> 5296 bytes .../build/faster_hexbytes/main.o | Bin 0 -> 5280 bytes 11 files changed, 4560 insertions(+) create mode 100644 build/__native_6a32f4913d613d6a7ddf.c create mode 100644 build/__native_6a32f4913d613d6a7ddf.h create mode 100644 build/__native_internal_6a32f4913d613d6a7ddf.h create mode 100644 build/faster_hexbytes.c create mode 100644 build/faster_hexbytes/_utils.c create mode 100644 build/faster_hexbytes/main.c create mode 100644 build/ops.txt create mode 100644 build/temp.linux-x86_64-cpython-313/build/__native_6a32f4913d613d6a7ddf.o create mode 100644 build/temp.linux-x86_64-cpython-313/build/faster_hexbytes.o create mode 100644 build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/_utils.o create mode 100644 build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/main.o diff --git a/build/__native_6a32f4913d613d6a7ddf.c b/build/__native_6a32f4913d613d6a7ddf.c new file mode 100644 index 0000000..136c015 --- /dev/null +++ b/build/__native_6a32f4913d613d6a7ddf.c @@ -0,0 +1,2975 @@ +#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[3]; /* '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[67]; /* ('version',) */ + cpy_r_r6 = CPyStatics[68]; /* ('__version',) */ + cpy_r_r7 = CPyStatics[6]; /* '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", "", 1, 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[69]; /* ('HexBytes',) */ + cpy_r_r11 = CPyStatics[8]; /* '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", "", 5, 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[7]; /* 'HexBytes' */ + cpy_r_r15 = PyList_New(1); + if (unlikely(cpy_r_r15 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", 9, 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[9]; /* '__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", "", 9, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + cpy_r_r22 = CPyStatics[10]; /* 'hexbytes' */ + cpy_r_r23 = CPyStatic_faster_hexbytes___globals; + cpy_r_r24 = CPyStatics[5]; /* '__version' */ + cpy_r_r25 = CPyDict_GetItem(cpy_r_r23, cpy_r_r24); + if (unlikely(cpy_r_r25 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", 11, 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", "", 11, 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[11]; /* '__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", "", 11, 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); + 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", 15, 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", 17, 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", 17, 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", 19, 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", 19, 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", 21, CPyStatic__utils___globals); + goto CPyL51; + } + if (!cpy_r_r12) goto CPyL15; + cpy_r_r13 = CPyStatics[65]; /* b'\x01' */ + CPy_INCREF(cpy_r_r13); + cpy_r_r14 = cpy_r_r13; + goto CPyL16; +CPyL15: ; + cpy_r_r15 = CPyStatics[66]; /* 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", 25, 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[12]; /* '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", 26, 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", 26, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r28 = CPyStatics[13]; /* ' 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", 26, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r30 = CPyModule_builtins; + cpy_r_r31 = CPyStatics[14]; /* '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", 26, 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", 26, 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", 26, 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", 28, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r37 = CPyModule_builtins; + cpy_r_r38 = CPyStatics[15]; /* '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", 28, 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", 28, 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", 28, 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", 28, CPyStatic__utils___globals); + goto CPyL51; + } + return cpy_r_r45; +CPyL37: ; + cpy_r_r46 = CPyModule_builtins; + cpy_r_r47 = CPyStatics[16]; /* '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", 29, 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", 29, 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", 30, 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", 30, CPyStatic__utils___globals, "bytes", cpy_r_r55); + goto CPyL51; + } + return cpy_r_r56; +CPyL43: ; + cpy_r_r57 = CPyStatics[17]; /* '' */ + cpy_r_r58 = CPyStatics[18]; /* 'Cannot convert ' */ + cpy_r_r59 = CPyStatics[19]; /* '{!r:{}}' */ + cpy_r_r60 = CPyStatics[17]; /* '' */ + cpy_r_r61 = CPyStatics[20]; /* '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", 32, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r65 = CPyStatics[21]; /* ' of type ' */ + cpy_r_r66 = CPyStatics[22]; /* '{:{}}' */ + cpy_r_r67 = CPy_TYPE(cpy_r_val); + cpy_r_r68 = CPyStatics[17]; /* '' */ + cpy_r_r69 = CPyStatics[20]; /* '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", 32, CPyStatic__utils___globals); + goto CPyL55; + } + CPy_DECREF(cpy_r_r67); + cpy_r_r73 = CPyStatics[13]; /* ' to bytes' */ + cpy_r_r74 = PyList_New(5); + if (unlikely(cpy_r_r74 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 32, 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", 32, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r82 = CPyModule_builtins; + cpy_r_r83 = CPyStatics[23]; /* '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", 32, 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", 32, 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", 32, 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 (PyBool_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 (PyBytes_Check(obj_val) || PyByteArray_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; + if (PyUnicode_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL1; + CPy_TypeError("union[bool, object, bytes, int, str]", obj_val); + goto fail; +__LL1: ; + PyObject *retval = CPyDef__utils___to_bytes(arg_val); + return retval; +fail: ; + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 7, 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; + PyObject *cpy_r_r31; + PyObject *cpy_r_r32; + PyObject **cpy_r_r34; + PyObject *cpy_r_r35; + PyObject *cpy_r_r36; + PyObject *cpy_r_r37; + cpy_r_r0 = CPyStatics[24]; /* '0x' */ + cpy_r_r1 = CPyStatics[25]; /* '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", 36, CPyStatic__utils___globals); + goto CPyL29; + } + 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", 37, CPyStatic__utils___globals); + goto CPyL29; + } + if (likely(PyUnicode_Check(cpy_r_r5))) + cpy_r_r6 = cpy_r_r5; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 37, CPyStatic__utils___globals, "str", cpy_r_r5); + goto CPyL29; + } + 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", 42, CPyStatic__utils___globals); + goto CPyL30; + } + 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", 42, CPyStatic__utils___globals); + goto CPyL30; + } + cpy_r_r11 = cpy_r_r10 != 0; + CPyTagged_DECREF(cpy_r_r10); + if (!cpy_r_r11) goto CPyL11; + cpy_r_r12 = CPyStatics[26]; /* '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", 43, CPyStatic__utils___globals); + goto CPyL29; + } + 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", 48, CPyStatic__utils___globals); + goto CPyL14; + } else + goto CPyL31; +CPyL13: ; + goto CPyL25; +CPyL14: ; + cpy_r_r15 = CPy_CatchError(); + cpy_r_r16 = CPyModule_builtins; + cpy_r_r17 = CPyStatics[27]; /* '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", 49, CPyStatic__utils___globals); + goto CPyL32; + } + cpy_r_r19 = CPy_ExceptionMatches(cpy_r_r18); + CPy_DecRef(cpy_r_r18); + if (!cpy_r_r19) goto CPyL33; + cpy_r_r20 = CPyStatics[28]; /* 'hex string ' */ + cpy_r_r21 = CPyStatics[29]; /* ' 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", 51, CPyStatic__utils___globals); + goto CPyL23; + } + cpy_r_r23 = CPyModule_builtins; + cpy_r_r24 = CPyStatics[14]; /* '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", 50, CPyStatic__utils___globals); + goto CPyL34; + } + 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", 50, CPyStatic__utils___globals); + goto CPyL34; + } + 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", 50, CPyStatic__utils___globals); + goto CPyL23; + } else + goto CPyL35; +CPyL20: ; + CPy_Unreachable(); +CPyL21: ; + CPy_Reraise(); + if (!0) { + goto CPyL23; + } else + goto CPyL36; +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 CPyL29; + CPy_Unreachable(); +CPyL25: ; + cpy_r_r30 = CPyModule_binascii; + cpy_r_r31 = CPyStatics[30]; /* 'unhexlify' */ + cpy_r_r32 = CPyObject_GetAttr(cpy_r_r30, cpy_r_r31); + if (unlikely(cpy_r_r32 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 54, CPyStatic__utils___globals); + goto CPyL37; + } + PyObject *cpy_r_r33[1] = {cpy_r_r14}; + 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", "hexstr_to_bytes", 54, CPyStatic__utils___globals); + goto CPyL37; + } + CPy_DECREF(cpy_r_r14); + if (likely(PyBytes_Check(cpy_r_r35) || PyByteArray_Check(cpy_r_r35))) + cpy_r_r36 = cpy_r_r35; + else { + CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 54, CPyStatic__utils___globals, "bytes", cpy_r_r35); + goto CPyL29; + } + return cpy_r_r36; +CPyL29: ; + cpy_r_r37 = NULL; + return cpy_r_r37; +CPyL30: ; + CPy_DecRef(cpy_r_non_prefixed_hex); + goto CPyL29; +CPyL31: ; + CPy_DECREF(cpy_r_padded_hex); + goto CPyL13; +CPyL32: ; + CPy_DecRef(cpy_r_padded_hex); + goto CPyL23; +CPyL33: ; + CPy_DecRef(cpy_r_padded_hex); + goto CPyL21; +CPyL34: ; + CPy_DecRef(cpy_r_r22); + goto CPyL23; +CPyL35: ; + CPy_DecRef(cpy_r_r15.f0); + CPy_DecRef(cpy_r_r15.f1); + CPy_DecRef(cpy_r_r15.f2); + goto CPyL20; +CPyL36: ; + CPy_DecRef(cpy_r_r15.f0); + CPy_DecRef(cpy_r_r15.f1); + CPy_DecRef(cpy_r_r15.f2); + goto CPyL22; +CPyL37: ; + CPy_DecRef(cpy_r_r14); + goto CPyL29; +} + +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", 35, 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; + char cpy_r_r19; + 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[3]; /* '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 CPyL6; + } + 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[71]; /* (('binascii', 'binascii', 'binascii'),) */ + cpy_r_r11 = CPyStatic__utils___globals; + cpy_r_r12 = CPyStatics[32]; /* 'faster_hexbytes/_utils.py' */ + cpy_r_r13 = CPyStatics[33]; /* '' */ + 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 CPyL6; + cpy_r_r15 = CPyStatics[72]; /* ('Union',) */ + cpy_r_r16 = CPyStatics[35]; /* '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", "", 2, CPyStatic__utils___globals); + goto CPyL6; + } + CPyModule_typing = cpy_r_r18; + CPy_INCREF(CPyModule_typing); + CPy_DECREF(cpy_r_r18); + return 1; +CPyL6: ; + cpy_r_r19 = 2; + return cpy_r_r19; +} + +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); + Py_CLEAR(CPyType_main___HexBytes); + 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; + PyObject *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__", 42, CPyStatic_main___globals); + goto CPyL4; + } + cpy_r_r1 = (PyObject *)&PyBytes_Type; + cpy_r_r2 = CPyStatics[36]; /* '__new__' */ + PyObject *cpy_r_r3[3] = {cpy_r_r1, cpy_r_cls, cpy_r_r0}; + cpy_r_r4 = (PyObject **)&cpy_r_r3; + cpy_r_r5 = PyObject_VectorcallMethod(cpy_r_r2, cpy_r_r4, 9223372036854775811ULL, 0); + if (unlikely(cpy_r_r5 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", 43, CPyStatic_main___globals); + goto CPyL5; + } + CPy_DECREF(cpy_r_r0); + if (likely(Py_TYPE(cpy_r_r5) == CPyType_main___HexBytes)) + cpy_r_r6 = cpy_r_r5; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__new__", 43, CPyStatic_main___globals, "faster_hexbytes.main.HexBytes", cpy_r_r5); + goto CPyL4; + } + return cpy_r_r6; +CPyL4: ; + cpy_r_r7 = NULL; + return cpy_r_r7; +CPyL5: ; + CPy_DecRef(cpy_r_r0); + goto CPyL4; +} + +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 (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 (PyBytes_Check(obj_val) || PyByteArray_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + 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; + if (PyUnicode_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL4; + CPy_TypeError("union[bool, object, bytes, int, str]", 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__", 41, 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_r2; + PyObject *cpy_r_r3; + PyObject **cpy_r_r5; + PyObject *cpy_r_r6; + PyObject *cpy_r_r7; + PyObject *cpy_r_r8; + 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_r17; + PyObject *cpy_r_r18; + PyObject *cpy_r_r19; + CPyTagged cpy_r_r20; + PyObject *cpy_r_r21; + PyObject *cpy_r_r22; + cpy_r_r0 = CPyModule_builtins; + cpy_r_r1 = CPyStatics[37]; /* 'super' */ + cpy_r_r2 = CPyObject_GetAttr(cpy_r_r0, cpy_r_r1); + if (unlikely(cpy_r_r2 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals); + goto CPyL11; + } + cpy_r_r3 = (PyObject *)CPyType_main___HexBytes; + PyObject *cpy_r_r4[2] = {cpy_r_r3, cpy_r_self}; + cpy_r_r5 = (PyObject **)&cpy_r_r4; + cpy_r_r6 = PyObject_Vectorcall(cpy_r_r2, cpy_r_r5, 2, 0); + CPy_DECREF(cpy_r_r2); + if (unlikely(cpy_r_r6 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals); + goto CPyL11; + } + cpy_r_r7 = CPyStatics[38]; /* '__getitem__' */ + cpy_r_r8 = CPyObject_GetAttr(cpy_r_r6, cpy_r_r7); + CPy_DECREF(cpy_r_r6); + if (unlikely(cpy_r_r8 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals); + goto CPyL11; + } + PyObject *cpy_r_r9[1] = {cpy_r_key}; + cpy_r_r10 = (PyObject **)&cpy_r_r9; + cpy_r_r11 = PyObject_Vectorcall(cpy_r_r8, cpy_r_r10, 1, 0); + CPy_DECREF(cpy_r_r8); + if (unlikely(cpy_r_r11 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals); + goto CPyL11; + } + if (PyLong_Check(cpy_r_r11)) + cpy_r_r12 = cpy_r_r11; + else { + cpy_r_r12 = NULL; + } + if (cpy_r_r12 != NULL) goto __LL5; + if (PyBytes_Check(cpy_r_r11) || PyByteArray_Check(cpy_r_r11)) + cpy_r_r12 = cpy_r_r11; + else { + cpy_r_r12 = NULL; + } + if (cpy_r_r12 != NULL) goto __LL5; + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals, "union[int, bytes]", cpy_r_r11); + goto CPyL11; +__LL5: ; + cpy_r_r13 = CPyStatics[15]; /* 'hex' */ + cpy_r_r14 = PyObject_HasAttr(cpy_r_r12, cpy_r_r13); + if (!cpy_r_r14) goto CPyL9; + cpy_r_r15 = CPy_TYPE(cpy_r_self); + PyObject *cpy_r_r16[1] = {cpy_r_r12}; + cpy_r_r17 = (PyObject **)&cpy_r_r16; + cpy_r_r18 = PyObject_Vectorcall(cpy_r_r15, cpy_r_r17, 1, 0); + CPy_DECREF(cpy_r_r15); + if (unlikely(cpy_r_r18 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 58, CPyStatic_main___globals); + goto CPyL12; + } + CPy_DECREF(cpy_r_r12); + if (likely(Py_TYPE(cpy_r_r18) == CPyType_main___HexBytes)) + cpy_r_r19 = cpy_r_r18; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 58, CPyStatic_main___globals, "faster_hexbytes.main.HexBytes", cpy_r_r18); + goto CPyL11; + } + return cpy_r_r19; +CPyL9: ; + if (likely(PyLong_Check(cpy_r_r12))) + cpy_r_r20 = CPyTagged_FromObject(cpy_r_r12); + else { + CPy_TypeError("int", cpy_r_r12); cpy_r_r20 = CPY_INT_TAG; + } + CPy_DECREF(cpy_r_r12); + if (unlikely(cpy_r_r20 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 60, CPyStatic_main___globals); + goto CPyL11; + } + cpy_r_r21 = CPyTagged_StealAsObject(cpy_r_r20); + return cpy_r_r21; +CPyL11: ; + cpy_r_r22 = NULL; + return cpy_r_r22; +CPyL12: ; + CPy_DecRef(cpy_r_r12); + goto CPyL11; +} + +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(Py_TYPE(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__", 53, 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_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + 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_r13; + PyObject *cpy_r_r14; + PyObject *cpy_r_r15; + PyObject *cpy_r_r16; + PyObject *cpy_r_r17; + CPyPtr cpy_r_r18; + CPyPtr cpy_r_r19; + CPyPtr cpy_r_r20; + CPyPtr cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + cpy_r_r0 = CPyStatics[17]; /* '' */ + cpy_r_r1 = CPyStatics[39]; /* 'HexBytes(' */ + cpy_r_r2 = CPyStatics[19]; /* '{!r:{}}' */ + cpy_r_r3 = CPyStatics[24]; /* '0x' */ + cpy_r_r4 = CPyStatics[15]; /* 'hex' */ + PyObject *cpy_r_r5[1] = {cpy_r_self}; + cpy_r_r6 = (PyObject **)&cpy_r_r5; + cpy_r_r7 = PyObject_VectorcallMethod(cpy_r_r4, cpy_r_r6, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r7 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); + goto CPyL8; + } + if (likely(PyUnicode_Check(cpy_r_r7))) + cpy_r_r8 = cpy_r_r7; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals, "str", cpy_r_r7); + goto CPyL8; + } + cpy_r_r9 = PyUnicode_Concat(cpy_r_r3, cpy_r_r8); + CPy_DECREF(cpy_r_r8); + if (unlikely(cpy_r_r9 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); + goto CPyL8; + } + cpy_r_r10 = CPyStatics[17]; /* '' */ + cpy_r_r11 = CPyStatics[20]; /* 'format' */ + PyObject *cpy_r_r12[3] = {cpy_r_r2, cpy_r_r9, cpy_r_r10}; + cpy_r_r13 = (PyObject **)&cpy_r_r12; + cpy_r_r14 = PyObject_VectorcallMethod(cpy_r_r11, cpy_r_r13, 9223372036854775811ULL, 0); + if (unlikely(cpy_r_r14 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); + goto CPyL9; + } + CPy_DECREF(cpy_r_r9); + if (likely(PyUnicode_Check(cpy_r_r14))) + cpy_r_r15 = cpy_r_r14; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals, "str", cpy_r_r14); + goto CPyL8; + } + cpy_r_r16 = CPyStatics[40]; /* ')' */ + cpy_r_r17 = PyList_New(3); + if (unlikely(cpy_r_r17 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); + goto CPyL10; + } + cpy_r_r18 = (CPyPtr)&((PyListObject *)cpy_r_r17)->ob_item; + cpy_r_r19 = *(CPyPtr *)cpy_r_r18; + CPy_INCREF(cpy_r_r1); + *(PyObject * *)cpy_r_r19 = cpy_r_r1; + cpy_r_r20 = cpy_r_r19 + 8; + *(PyObject * *)cpy_r_r20 = cpy_r_r15; + CPy_INCREF(cpy_r_r16); + cpy_r_r21 = cpy_r_r19 + 16; + *(PyObject * *)cpy_r_r21 = cpy_r_r16; + cpy_r_r22 = PyUnicode_Join(cpy_r_r0, cpy_r_r17); + CPy_DECREF_NO_IMM(cpy_r_r17); + if (unlikely(cpy_r_r22 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); + goto CPyL8; + } + return cpy_r_r22; +CPyL8: ; + cpy_r_r23 = NULL; + return cpy_r_r23; +CPyL9: ; + CPy_DecRef(cpy_r_r9); + goto CPyL8; +CPyL10: ; + CPy_DecRef(cpy_r_r15); + goto CPyL8; +} + +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(Py_TYPE(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__", 62, 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[24]; /* '0x' */ + cpy_r_r1 = CPyStatics[15]; /* '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", 69, 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", 69, CPyStatic_main___globals, "str", cpy_r_r4); + goto CPyL4; + } + cpy_r_r6 = PyUnicode_Concat(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", 69, 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(Py_TYPE(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", 65, 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; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + PyObject **cpy_r_r6; + PyObject *cpy_r_r7; + PyObject *cpy_r_r8; + tuple_T2OO cpy_r_r9; + tuple_T2OT2OO cpy_r_r10; + tuple_T2OT2OO cpy_r_r11; + cpy_r_r0 = (PyObject *)&PyBytes_Type; + cpy_r_r1 = CPyStatics[36]; /* '__new__' */ + cpy_r_r2 = CPyObject_GetAttr(cpy_r_r0, cpy_r_r1); + if (unlikely(cpy_r_r2 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", 79, CPyStatic_main___globals); + goto CPyL4; + } + cpy_r_r3 = CPy_TYPE(cpy_r_self); + cpy_r_r4 = (PyObject *)&PyBytes_Type; + PyObject *cpy_r_r5[1] = {cpy_r_self}; + cpy_r_r6 = (PyObject **)&cpy_r_r5; + cpy_r_r7 = PyObject_Vectorcall(cpy_r_r4, cpy_r_r6, 1, 0); + if (unlikely(cpy_r_r7 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", 79, CPyStatic_main___globals); + goto CPyL5; + } + if (likely(PyBytes_Check(cpy_r_r7) || PyByteArray_Check(cpy_r_r7))) + cpy_r_r8 = cpy_r_r7; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__reduce__", 79, CPyStatic_main___globals, "bytes", cpy_r_r7); + goto CPyL5; + } + cpy_r_r9.f0 = cpy_r_r3; + cpy_r_r9.f1 = cpy_r_r8; + cpy_r_r10.f0 = cpy_r_r2; + cpy_r_r10.f1 = cpy_r_r9; + return cpy_r_r10; +CPyL4: ; + tuple_T2OT2OO __tmp6 = { NULL, (tuple_T2OO) { NULL, NULL } }; + cpy_r_r11 = __tmp6; + return cpy_r_r11; +CPyL5: ; + CPy_DecRef(cpy_r_r2); + CPy_DecRef(cpy_r_r3); + goto CPyL4; +} + +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(Py_TYPE(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__", 71, 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; + PyObject *cpy_r_r10; + PyObject *cpy_r_r11; + PyObject *cpy_r_r12; + PyObject *cpy_r_r13; + PyObject *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; + 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; + tuple_T6OOOOOO cpy_r_r34; + PyObject *cpy_r_r35; + PyObject *cpy_r_r36; + PyObject *cpy_r_r37; + PyObject *cpy_r_r38; + int32_t cpy_r_r39; + char cpy_r_r40; + PyObject *cpy_r_r41; + PyObject *cpy_r_r42; + PyObject *cpy_r_r43; + PyObject *cpy_r_r44; + PyObject *cpy_r_r45; + PyObject *cpy_r_r46; + PyObject *cpy_r_r47; + char cpy_r_r48; + PyObject *cpy_r_r49; + PyObject *cpy_r_r50; + PyObject *cpy_r_r51; + PyObject **cpy_r_r53; + 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_r62; + PyObject **cpy_r_r64; + PyObject *cpy_r_r65; + PyObject *cpy_r_r66; + int32_t cpy_r_r67; + char cpy_r_r68; + PyObject *cpy_r_r69; + PyObject *cpy_r_r70; + int32_t cpy_r_r71; + char cpy_r_r72; + PyObject *cpy_r_r73; + PyObject *cpy_r_r74; + int32_t cpy_r_r75; + char cpy_r_r76; + PyObject *cpy_r_r77; + PyObject *cpy_r_r78; + int32_t cpy_r_r79; + char cpy_r_r80; + PyObject *cpy_r_r81; + PyObject *cpy_r_r82; + int32_t cpy_r_r83; + char cpy_r_r84; + PyObject *cpy_r_r85; + PyObject *cpy_r_r86; + int32_t cpy_r_r87; + char cpy_r_r88; + PyObject *cpy_r_r89; + PyObject *cpy_r_r90; + int32_t cpy_r_r91; + char cpy_r_r92; + PyObject *cpy_r_r93; + PyObject *cpy_r_r94; + int32_t cpy_r_r95; + char cpy_r_r96; + PyObject **cpy_r_r98; + PyObject *cpy_r_r99; + PyObject *cpy_r_r100; + PyObject *cpy_r_r101; + PyObject *cpy_r_r102; + PyObject *cpy_r_r103; + PyObject **cpy_r_r105; + PyObject *cpy_r_r106; + PyObject *cpy_r_r107; + PyObject **cpy_r_r109; + PyObject *cpy_r_r110; + PyObject *cpy_r_r111; + PyObject *cpy_r_r112; + int32_t cpy_r_r113; + char cpy_r_r114; + PyObject *cpy_r_r115; + char cpy_r_r116; + 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[3]; /* '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 CPyL45; + } + CPyModule_builtins = cpy_r_r4; + CPy_INCREF(CPyModule_builtins); + CPy_DECREF(cpy_r_r4); +CPyL3: ; + cpy_r_r5 = CPyStatics[73]; /* ('TYPE_CHECKING', 'Callable', 'Tuple', 'Type', 'Union', + 'overload') */ + cpy_r_r6 = CPyStatics[35]; /* '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", "", 1, CPyStatic_main___globals); + goto CPyL45; + } + CPyModule_typing = cpy_r_r8; + CPy_INCREF(CPyModule_typing); + CPy_DECREF(cpy_r_r8); + cpy_r_r9 = CPyStatics[74]; /* ('mypyc_attr',) */ + cpy_r_r10 = CPyStatics[47]; /* 'mypy_extensions' */ + cpy_r_r11 = CPyStatic_main___globals; + cpy_r_r12 = CPyImport_ImportFromMany(cpy_r_r10, cpy_r_r9, cpy_r_r9, cpy_r_r11); + if (unlikely(cpy_r_r12 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 10, CPyStatic_main___globals); + goto CPyL45; + } + CPyModule_mypy_extensions = cpy_r_r12; + CPy_INCREF(CPyModule_mypy_extensions); + CPy_DECREF(cpy_r_r12); + cpy_r_r13 = CPyStatics[75]; /* ('Self',) */ + cpy_r_r14 = CPyStatics[49]; /* 'typing_extensions' */ + cpy_r_r15 = CPyStatic_main___globals; + cpy_r_r16 = CPyImport_ImportFromMany(cpy_r_r14, cpy_r_r13, cpy_r_r13, cpy_r_r15); + if (unlikely(cpy_r_r16 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 13, CPyStatic_main___globals); + goto CPyL45; + } + CPyModule_typing_extensions = cpy_r_r16; + CPy_INCREF(CPyModule_typing_extensions); + CPy_DECREF(cpy_r_r16); + cpy_r_r17 = CPyStatics[76]; /* ('to_bytes',) */ + cpy_r_r18 = CPyStatics[51]; /* 'faster_hexbytes._utils' */ + cpy_r_r19 = CPyStatic_main___globals; + cpy_r_r20 = CPyImport_ImportFromMany(cpy_r_r18, cpy_r_r17, cpy_r_r17, cpy_r_r19); + if (unlikely(cpy_r_r20 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 17, CPyStatic_main___globals); + goto CPyL45; + } + CPyModule_faster_hexbytes____utils = cpy_r_r20; + CPy_INCREF(CPyModule_faster_hexbytes____utils); + CPy_DECREF(cpy_r_r20); + cpy_r_r21 = CPyStatic_main___globals; + cpy_r_r22 = CPyStatics[34]; /* 'Union' */ + cpy_r_r23 = CPyDict_GetItem(cpy_r_r21, cpy_r_r22); + if (unlikely(cpy_r_r23 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); + goto CPyL45; + } + cpy_r_r24 = (PyObject *)&PyBool_Type; + cpy_r_r25 = CPyModule_builtins; + cpy_r_r26 = CPyStatics[52]; /* 'bytearray' */ + cpy_r_r27 = CPyObject_GetAttr(cpy_r_r25, cpy_r_r26); + if (unlikely(cpy_r_r27 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); + goto CPyL46; + } + cpy_r_r28 = (PyObject *)&PyBytes_Type; + cpy_r_r29 = (PyObject *)&PyLong_Type; + cpy_r_r30 = (PyObject *)&PyUnicode_Type; + cpy_r_r31 = CPyModule_builtins; + cpy_r_r32 = CPyStatics[16]; /* 'memoryview' */ + cpy_r_r33 = CPyObject_GetAttr(cpy_r_r31, cpy_r_r32); + if (unlikely(cpy_r_r33 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); + goto CPyL47; + } + CPy_INCREF(cpy_r_r24); + CPy_INCREF(cpy_r_r28); + CPy_INCREF(cpy_r_r29); + CPy_INCREF(cpy_r_r30); + cpy_r_r34.f0 = cpy_r_r24; + cpy_r_r34.f1 = cpy_r_r27; + cpy_r_r34.f2 = cpy_r_r28; + cpy_r_r34.f3 = cpy_r_r29; + cpy_r_r34.f4 = cpy_r_r30; + cpy_r_r34.f5 = cpy_r_r33; + cpy_r_r35 = PyTuple_New(6); + if (unlikely(cpy_r_r35 == NULL)) + CPyError_OutOfMemory(); + PyObject *__tmp11 = cpy_r_r34.f0; + PyTuple_SET_ITEM(cpy_r_r35, 0, __tmp11); + PyObject *__tmp12 = cpy_r_r34.f1; + PyTuple_SET_ITEM(cpy_r_r35, 1, __tmp12); + PyObject *__tmp13 = cpy_r_r34.f2; + PyTuple_SET_ITEM(cpy_r_r35, 2, __tmp13); + PyObject *__tmp14 = cpy_r_r34.f3; + PyTuple_SET_ITEM(cpy_r_r35, 3, __tmp14); + PyObject *__tmp15 = cpy_r_r34.f4; + PyTuple_SET_ITEM(cpy_r_r35, 4, __tmp15); + PyObject *__tmp16 = cpy_r_r34.f5; + PyTuple_SET_ITEM(cpy_r_r35, 5, __tmp16); + cpy_r_r36 = PyObject_GetItem(cpy_r_r23, cpy_r_r35); + CPy_DECREF(cpy_r_r23); + CPy_DECREF(cpy_r_r35); + if (unlikely(cpy_r_r36 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); + goto CPyL45; + } + cpy_r_r37 = CPyStatic_main___globals; + cpy_r_r38 = CPyStatics[53]; /* 'BytesLike' */ + cpy_r_r39 = CPyDict_SetItem(cpy_r_r37, cpy_r_r38, cpy_r_r36); + CPy_DECREF(cpy_r_r36); + cpy_r_r40 = cpy_r_r39 >= 0; + if (unlikely(!cpy_r_r40)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); + goto CPyL45; + } + cpy_r_r41 = CPyModule_builtins; + cpy_r_r42 = CPyStatics[54]; /* 'bytes' */ + cpy_r_r43 = CPyObject_GetAttr(cpy_r_r41, cpy_r_r42); + if (unlikely(cpy_r_r43 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL45; + } + cpy_r_r44 = PyTuple_Pack(1, cpy_r_r43); + CPy_DECREF(cpy_r_r43); + if (unlikely(cpy_r_r44 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL45; + } + cpy_r_r45 = (PyObject *)&PyType_Type; + cpy_r_r46 = CPy_CalculateMetaclass(cpy_r_r45, cpy_r_r44); + if (unlikely(cpy_r_r46 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL48; + } + cpy_r_r47 = CPyStatics[55]; /* '__prepare__' */ + cpy_r_r48 = PyObject_HasAttr(cpy_r_r46, cpy_r_r47); + if (!cpy_r_r48) goto CPyL21; + cpy_r_r49 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r50 = CPyStatics[55]; /* '__prepare__' */ + cpy_r_r51 = CPyObject_GetAttr(cpy_r_r46, cpy_r_r50); + if (unlikely(cpy_r_r51 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL48; + } + PyObject *cpy_r_r52[2] = {cpy_r_r49, cpy_r_r44}; + cpy_r_r53 = (PyObject **)&cpy_r_r52; + cpy_r_r54 = PyObject_Vectorcall(cpy_r_r51, cpy_r_r53, 2, 0); + CPy_DECREF(cpy_r_r51); + if (unlikely(cpy_r_r54 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL48; + } + if (likely(PyDict_Check(cpy_r_r54))) + cpy_r_r55 = cpy_r_r54; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals, "dict", cpy_r_r54); + goto CPyL48; + } + cpy_r_r56 = cpy_r_r55; + goto CPyL23; +CPyL21: ; + cpy_r_r57 = PyDict_New(); + if (unlikely(cpy_r_r57 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL48; + } + cpy_r_r56 = cpy_r_r57; +CPyL23: ; + cpy_r_r58 = PyDict_New(); + if (unlikely(cpy_r_r58 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL49; + } + cpy_r_r59 = CPyDef_main_____new___3_HexBytes_obj(); + if (unlikely(cpy_r_r59 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 41, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r60 = CPyModule_builtins; + cpy_r_r61 = CPyStatics[56]; /* 'staticmethod' */ + cpy_r_r62 = CPyObject_GetAttr(cpy_r_r60, cpy_r_r61); + if (unlikely(cpy_r_r62 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 41, CPyStatic_main___globals); + goto CPyL51; + } + PyObject *cpy_r_r63[1] = {cpy_r_r59}; + cpy_r_r64 = (PyObject **)&cpy_r_r63; + cpy_r_r65 = PyObject_Vectorcall(cpy_r_r62, cpy_r_r64, 1, 0); + CPy_DECREF(cpy_r_r62); + if (unlikely(cpy_r_r65 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 41, CPyStatic_main___globals); + goto CPyL51; + } + CPy_DECREF_NO_IMM(cpy_r_r59); + cpy_r_r66 = CPyStatics[36]; /* '__new__' */ + cpy_r_r67 = CPyDict_SetItem(cpy_r_r56, cpy_r_r66, cpy_r_r65); + CPy_DECREF(cpy_r_r65); + cpy_r_r68 = cpy_r_r67 >= 0; + if (unlikely(!cpy_r_r68)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 41, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r69 = CPyDef_main_____getitem___3_HexBytes_obj(); + if (unlikely(cpy_r_r69 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 53, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r70 = CPyStatics[38]; /* '__getitem__' */ + cpy_r_r71 = CPyDict_SetItem(cpy_r_r56, cpy_r_r70, cpy_r_r69); + CPy_DECREF_NO_IMM(cpy_r_r69); + cpy_r_r72 = cpy_r_r71 >= 0; + if (unlikely(!cpy_r_r72)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 53, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r73 = CPyDef_main_____repr___3_HexBytes_obj(); + if (unlikely(cpy_r_r73 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 62, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r74 = CPyStatics[57]; /* '__repr__' */ + cpy_r_r75 = CPyDict_SetItem(cpy_r_r56, cpy_r_r74, cpy_r_r73); + CPy_DECREF_NO_IMM(cpy_r_r73); + cpy_r_r76 = cpy_r_r75 >= 0; + if (unlikely(!cpy_r_r76)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 62, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r77 = CPyDef_main___to_0x_hex_HexBytes_obj(); + if (unlikely(cpy_r_r77 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 65, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r78 = CPyStatics[58]; /* 'to_0x_hex' */ + cpy_r_r79 = CPyDict_SetItem(cpy_r_r56, cpy_r_r78, cpy_r_r77); + CPy_DECREF_NO_IMM(cpy_r_r77); + cpy_r_r80 = cpy_r_r79 >= 0; + if (unlikely(!cpy_r_r80)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 65, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r81 = CPyDef_main_____reduce___3_HexBytes_obj(); + if (unlikely(cpy_r_r81 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 71, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r82 = CPyStatics[59]; /* '__reduce__' */ + cpy_r_r83 = CPyDict_SetItem(cpy_r_r56, cpy_r_r82, cpy_r_r81); + CPy_DECREF_NO_IMM(cpy_r_r81); + cpy_r_r84 = cpy_r_r83 >= 0; + if (unlikely(!cpy_r_r84)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 71, CPyStatic_main___globals); + goto CPyL50; + } + cpy_r_r85 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r86 = CPyStatics[60]; /* '__annotations__' */ + cpy_r_r87 = CPyDict_SetItem(cpy_r_r56, cpy_r_r86, cpy_r_r58); + CPy_DECREF(cpy_r_r58); + cpy_r_r88 = cpy_r_r87 >= 0; + if (unlikely(!cpy_r_r88)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL49; + } + cpy_r_r89 = CPyStatics[61]; /* 'mypyc filler docstring' */ + cpy_r_r90 = CPyStatics[62]; /* '__doc__' */ + cpy_r_r91 = CPyDict_SetItem(cpy_r_r56, cpy_r_r90, cpy_r_r89); + cpy_r_r92 = cpy_r_r91 >= 0; + if (unlikely(!cpy_r_r92)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL49; + } + cpy_r_r93 = CPyStatics[8]; /* 'faster_hexbytes.main' */ + cpy_r_r94 = CPyStatics[63]; /* '__module__' */ + cpy_r_r95 = CPyDict_SetItem(cpy_r_r56, cpy_r_r94, cpy_r_r93); + cpy_r_r96 = cpy_r_r95 >= 0; + if (unlikely(!cpy_r_r96)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL49; + } + PyObject *cpy_r_r97[3] = {cpy_r_r85, cpy_r_r44, cpy_r_r56}; + cpy_r_r98 = (PyObject **)&cpy_r_r97; + cpy_r_r99 = PyObject_Vectorcall(cpy_r_r46, cpy_r_r98, 3, 0); + if (unlikely(cpy_r_r99 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL49; + } + CPy_DECREF(cpy_r_r56); + CPy_DECREF(cpy_r_r44); + cpy_r_r100 = CPyStatic_main___globals; + cpy_r_r101 = CPyStatics[46]; /* 'mypyc_attr' */ + cpy_r_r102 = CPyDict_GetItem(cpy_r_r100, cpy_r_r101); + if (unlikely(cpy_r_r102 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 29, CPyStatic_main___globals); + goto CPyL52; + } + cpy_r_r103 = 0 ? Py_True : Py_False; + PyObject *cpy_r_r104[1] = {cpy_r_r103}; + cpy_r_r105 = (PyObject **)&cpy_r_r104; + cpy_r_r106 = CPyStatics[77]; /* ('native_class',) */ + cpy_r_r107 = PyObject_Vectorcall(cpy_r_r102, cpy_r_r105, 0, cpy_r_r106); + CPy_DECREF(cpy_r_r102); + if (unlikely(cpy_r_r107 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 29, CPyStatic_main___globals); + goto CPyL52; + } + PyObject *cpy_r_r108[1] = {cpy_r_r99}; + cpy_r_r109 = (PyObject **)&cpy_r_r108; + cpy_r_r110 = PyObject_Vectorcall(cpy_r_r107, cpy_r_r109, 1, 0); + CPy_DECREF(cpy_r_r107); + if (unlikely(cpy_r_r110 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL52; + } + CPy_DECREF(cpy_r_r99); + CPyType_main___HexBytes = (PyTypeObject *)cpy_r_r110; + CPy_INCREF(CPyType_main___HexBytes); + cpy_r_r111 = CPyStatic_main___globals; + cpy_r_r112 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r113 = PyDict_SetItem(cpy_r_r111, cpy_r_r112, cpy_r_r110); + CPy_DECREF(cpy_r_r110); + cpy_r_r114 = cpy_r_r113 >= 0; + if (unlikely(!cpy_r_r114)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); + goto CPyL45; + } + cpy_r_r115 = (PyObject *)CPyType_main___HexBytes; + return 1; +CPyL45: ; + cpy_r_r116 = 2; + return cpy_r_r116; +CPyL46: ; + CPy_DecRef(cpy_r_r23); + goto CPyL45; +CPyL47: ; + CPy_DecRef(cpy_r_r23); + CPy_DecRef(cpy_r_r27); + goto CPyL45; +CPyL48: ; + CPy_DecRef(cpy_r_r44); + goto CPyL45; +CPyL49: ; + CPy_DecRef(cpy_r_r44); + CPy_DecRef(cpy_r_r56); + goto CPyL45; +CPyL50: ; + CPy_DecRef(cpy_r_r44); + CPy_DecRef(cpy_r_r56); + CPy_DecRef(cpy_r_r58); + goto CPyL45; +CPyL51: ; + CPy_DecRef(cpy_r_r44); + CPy_DecRef(cpy_r_r56); + CPy_DecRef(cpy_r_r58); + CPy_DecRef(cpy_r_r59); + goto CPyL45; +CPyL52: ; + CPy_DecRef(cpy_r_r99); + goto CPyL45; +} + +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_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[78]; +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 ", + "\003( may only contain [0-9a-fA-F] characters\tunhexlify\bbinascii", + "\006\031faster_hexbytes/_utils.py\b\005Union\006typing\a__new__\005super", + "\b\v__getitem__\tHexBytes(\001)\rTYPE_CHECKING\bCallable\005Tuple\004Type\boverload", + "\005\nmypyc_attr\017mypy_extensions\004Self\021typing_extensions\bto_bytes", + "\005\026faster_hexbytes._utils\tbytearray\tBytesLike\005bytes\v__prepare__", + "\005\fstaticmethod\b__repr__\tto_0x_hex\n__reduce__\017__annotations__", + "\004\026mypyc filler docstring\a__doc__\n__module__\fnative_class", + "", +}; +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[] = { + 11, 1, 4, 1, 5, 1, 7, 3, 31, 31, 31, 1, 70, 1, 34, 6, 41, 42, 43, + 44, 34, 45, 1, 46, 1, 48, 1, 50, 1, 64 +}; +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_mypy_extensions; +CPyModule *CPyModule_typing_extensions; +char CPyDef_faster_hexbytes_____top_level__(void); +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); +PyTypeObject *CPyType_main___HexBytes; +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..9277403 --- /dev/null +++ b/build/__native_internal_6a32f4913d613d6a7ddf.h @@ -0,0 +1,75 @@ +#ifndef MYPYC_NATIVE_INTERNAL_6a32f4913d613d6a7ddf_H +#define MYPYC_NATIVE_INTERNAL_6a32f4913d613d6a7ddf_H +#include +#include +#include "__native_6a32f4913d613d6a7ddf.h" + +int CPyGlobalsInit(void); + +extern PyObject *CPyStatics[78]; +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_mypy_extensions; +extern CPyModule *CPyModule_typing_extensions; +extern char CPyDef_faster_hexbytes_____top_level__(void); +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 PyTypeObject *CPyType_main___HexBytes; +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..c09d246 --- /dev/null +++ b/build/faster_hexbytes.c @@ -0,0 +1,21 @@ +#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..88781dd --- /dev/null +++ b/build/ops.txt @@ -0,0 +1,1375 @@ +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[bool, object, bytes, int, str] + r0 :: bytes + r1 :: object + r2 :: str + r3 :: object[3] + r4 :: object_ptr + r5 :: object + r6, r7 :: faster_hexbytes.main.HexBytes +L0: + r0 = to_bytes(val) + if is_error(r0) goto L4 (error at __new__:42) else goto L1 +L1: + r1 = load_address PyBytes_Type + r2 = '__new__' + r3 = [r1, cls, r0] + r4 = load_address r3 + r5 = PyObject_VectorcallMethod(r2, r4, 9223372036854775811, 0) + if is_error(r5) goto L5 (error at __new__:43) else goto L2 +L2: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L4 (error at __new__:43) else goto L3 +L3: + return r6 +L4: + r7 = :: faster_hexbytes.main.HexBytes + return r7 +L5: + dec_ref r0 + goto L4 + +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, r3 :: object + r4 :: object[2] + r5 :: object_ptr + r6 :: object + r7 :: str + r8 :: object + r9 :: object[1] + r10 :: object_ptr + r11 :: object + r12 :: union[int, bytes] + r13 :: str + r14 :: bool + r15 :: object + r16 :: object[1] + r17 :: object_ptr + r18 :: object + r19 :: faster_hexbytes.main.HexBytes + r20 :: int + r21 :: object + r22 :: union[int, bytes, faster_hexbytes.main.HexBytes] +L0: + r0 = builtins :: module + r1 = 'super' + r2 = CPyObject_GetAttr(r0, r1) + if is_error(r2) goto L11 (error at __getitem__:56) else goto L1 +L1: + r3 = faster_hexbytes.main.HexBytes :: type + r4 = [r3, self] + r5 = load_address r4 + r6 = PyObject_Vectorcall(r2, r5, 2, 0) + dec_ref r2 + if is_error(r6) goto L11 (error at __getitem__:56) else goto L2 +L2: + r7 = '__getitem__' + r8 = CPyObject_GetAttr(r6, r7) + dec_ref r6 + if is_error(r8) goto L11 (error at __getitem__:56) else goto L3 +L3: + r9 = [key] + r10 = load_address r9 + r11 = PyObject_Vectorcall(r8, r10, 1, 0) + dec_ref r8 + if is_error(r11) goto L11 (error at __getitem__:56) else goto L4 +L4: + r12 = cast(union[int, bytes], r11) + if is_error(r12) goto L11 (error at __getitem__:56) else goto L5 +L5: + r13 = 'hex' + r14 = PyObject_HasAttr(r12, r13) + if r14 goto L6 else goto L9 :: bool +L6: + r15 = CPy_TYPE(self) + r16 = [r12] + r17 = load_address r16 + r18 = PyObject_Vectorcall(r15, r17, 1, 0) + dec_ref r15 + if is_error(r18) goto L12 (error at __getitem__:58) else goto L7 +L7: + dec_ref r12 + r19 = cast(faster_hexbytes.main.HexBytes, r18) + if is_error(r19) goto L11 (error at __getitem__:58) else goto L8 +L8: + return r19 +L9: + r20 = unbox(int, r12) + dec_ref r12 + if is_error(r20) goto L11 (error at __getitem__:60) else goto L10 +L10: + r21 = box(int, r20) + return r21 +L11: + r22 = :: union[int, bytes, faster_hexbytes.main.HexBytes] + return r22 +L12: + dec_ref r12 + goto L11 + +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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:63) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:63) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) + dec_ref r8 + if is_error(r9) goto L8 (error at __repr__:63) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] + r13 = load_address r12 + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:63) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:63) else goto L5 +L5: + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:63) else goto L6 +L6: + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:63) else goto L7 +L7: + return r22 +L8: + r23 = :: str + return r23 +L9: + dec_ref r9 + goto L8 +L10: + dec_ref r15 + goto L8 + +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:69) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:69) else goto L2 +L2: + r6 = PyUnicode_Concat(r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:69) 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 :: str + r2, r3, r4 :: object + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8 :: bytes + r9 :: tuple[object, bytes] + r10, r11 :: tuple[object, tuple[object, bytes]] +L0: + r0 = load_address PyBytes_Type + r1 = '__new__' + r2 = CPyObject_GetAttr(r0, r1) + if is_error(r2) goto L4 (error at __reduce__:79) else goto L1 +L1: + r3 = CPy_TYPE(self) + r4 = load_address PyBytes_Type + r5 = [self] + r6 = load_address r5 + r7 = PyObject_Vectorcall(r4, r6, 1, 0) + if is_error(r7) goto L5 (error at __reduce__:79) else goto L2 +L2: + r8 = cast(bytes, r7) + if is_error(r8) goto L5 (error at __reduce__:79) else goto L3 +L3: + r9 = (r3, r8) + r10 = (r2, r9) + return r10 +L4: + r11 = :: tuple[object, tuple[object, bytes]] + return r11 +L5: + dec_ref r2 + dec_ref r3 + goto L4 + +def __top_level__(): + r0, r1 :: object + r2 :: bit + r3 :: str + r4, r5 :: object + r6 :: str + r7 :: dict + r8, r9 :: object + r10 :: str + r11 :: dict + r12, r13 :: object + r14 :: str + r15 :: dict + r16, r17 :: object + r18 :: str + r19 :: dict + r20 :: object + r21 :: dict + r22 :: str + r23, r24, r25 :: object + r26 :: str + r27, r28, r29, r30, r31 :: object + r32 :: str + r33 :: object + r34 :: tuple[object, object, object, object, object, object] + r35, r36 :: object + r37 :: dict + r38 :: str + r39 :: i32 + r40 :: bit + r41 :: object + r42 :: str + r43 :: object + r44 :: tuple + r45, r46 :: object + r47 :: str + r48 :: bool + r49, r50 :: str + r51 :: object + r52 :: object[2] + r53 :: object_ptr + r54 :: object + r55, r56, r57, r58 :: dict + r59 :: faster_hexbytes.main.__new___HexBytes_obj + r60 :: object + r61 :: str + r62 :: object + r63 :: object[1] + r64 :: object_ptr + r65 :: object + r66 :: str + r67 :: i32 + r68 :: bit + r69 :: faster_hexbytes.main.__getitem___HexBytes_obj + r70 :: str + r71 :: i32 + r72 :: bit + r73 :: faster_hexbytes.main.__repr___HexBytes_obj + r74 :: str + r75 :: i32 + r76 :: bit + r77 :: faster_hexbytes.main.to_0x_hex_HexBytes_obj + r78 :: str + r79 :: i32 + r80 :: bit + r81 :: faster_hexbytes.main.__reduce___HexBytes_obj + r82 :: str + r83 :: i32 + r84 :: bit + r85, r86 :: str + r87 :: i32 + r88 :: bit + r89, r90 :: str + r91 :: i32 + r92 :: bit + r93, r94 :: str + r95 :: i32 + r96 :: bit + r97 :: object[3] + r98 :: object_ptr + r99 :: object + r100 :: dict + r101 :: str + r102, r103 :: object + r104 :: object[1] + r105 :: object_ptr + r106, r107 :: object + r108 :: object[1] + r109 :: object_ptr + r110 :: object + r111 :: dict + r112 :: str + r113 :: i32 + r114 :: bit + r115 :: object + r116 :: 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 L45 (error at :-1) else goto L2 +L2: + builtins = r4 :: module + dec_ref r4 +L3: + r5 = ('TYPE_CHECKING', 'Callable', 'Tuple', 'Type', 'Union', 'overload') + r6 = 'typing' + r7 = faster_hexbytes.main.globals :: static + r8 = CPyImport_ImportFromMany(r6, r5, r5, r7) + if is_error(r8) goto L45 (error at :1) else goto L4 +L4: + typing = r8 :: module + dec_ref r8 + r9 = ('mypyc_attr',) + r10 = 'mypy_extensions' + r11 = faster_hexbytes.main.globals :: static + r12 = CPyImport_ImportFromMany(r10, r9, r9, r11) + if is_error(r12) goto L45 (error at :10) else goto L5 +L5: + mypy_extensions = r12 :: module + dec_ref r12 + r13 = ('Self',) + r14 = 'typing_extensions' + r15 = faster_hexbytes.main.globals :: static + r16 = CPyImport_ImportFromMany(r14, r13, r13, r15) + if is_error(r16) goto L45 (error at :13) else goto L6 +L6: + typing_extensions = r16 :: module + dec_ref r16 + r17 = ('to_bytes',) + r18 = 'faster_hexbytes._utils' + r19 = faster_hexbytes.main.globals :: static + r20 = CPyImport_ImportFromMany(r18, r17, r17, r19) + if is_error(r20) goto L45 (error at :17) else goto L7 +L7: + faster_hexbytes._utils = r20 :: module + dec_ref r20 + if 0 goto L8 else goto L8 :: bool +L8: + r21 = faster_hexbytes.main.globals :: static + r22 = 'Union' + r23 = CPyDict_GetItem(r21, r22) + if is_error(r23) goto L45 (error at :26) else goto L9 +L9: + r24 = load_address PyBool_Type + r25 = builtins :: module + r26 = 'bytearray' + r27 = CPyObject_GetAttr(r25, r26) + if is_error(r27) goto L46 (error at :26) else goto L10 +L10: + r28 = load_address PyBytes_Type + r29 = load_address PyLong_Type + r30 = load_address PyUnicode_Type + r31 = builtins :: module + r32 = 'memoryview' + r33 = CPyObject_GetAttr(r31, r32) + if is_error(r33) goto L47 (error at :26) else goto L11 +L11: + inc_ref r24 + inc_ref r28 + inc_ref r29 + inc_ref r30 + r34 = (r24, r27, r28, r29, r30, r33) + r35 = box(tuple[object, object, object, object, object, object], r34) + r36 = PyObject_GetItem(r23, r35) + dec_ref r23 + dec_ref r35 + if is_error(r36) goto L45 (error at :26) else goto L12 +L12: + r37 = faster_hexbytes.main.globals :: static + r38 = 'BytesLike' + r39 = CPyDict_SetItem(r37, r38, r36) + dec_ref r36 + r40 = r39 >= 0 :: signed + if not r40 goto L45 (error at :26) else goto L13 :: bool +L13: + r41 = builtins :: module + r42 = 'bytes' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L45 (error at :30) else goto L14 +L14: + r44 = PyTuple_Pack(1, r43) + dec_ref r43 + if is_error(r44) goto L45 (error at :30) else goto L15 +L15: + r45 = load_address PyType_Type + r46 = CPy_CalculateMetaclass(r45, r44) + if is_error(r46) goto L48 (error at :30) else goto L16 +L16: + r47 = '__prepare__' + r48 = PyObject_HasAttr(r46, r47) + if r48 goto L17 else goto L21 :: bool +L17: + r49 = 'HexBytes' + r50 = '__prepare__' + r51 = CPyObject_GetAttr(r46, r50) + if is_error(r51) goto L48 (error at :30) else goto L18 +L18: + r52 = [r49, r44] + r53 = load_address r52 + r54 = PyObject_Vectorcall(r51, r53, 2, 0) + dec_ref r51 + if is_error(r54) goto L48 (error at :30) else goto L19 +L19: + r55 = cast(dict, r54) + if is_error(r55) goto L48 (error at :30) else goto L20 +L20: + r56 = r55 + goto L23 +L21: + r57 = PyDict_New() + if is_error(r57) goto L48 (error at :30) else goto L22 +L22: + r56 = r57 +L23: + r58 = PyDict_New() + if is_error(r58) goto L49 (error at :30) else goto L24 +L24: + r59 = __new___HexBytes_obj() + if is_error(r59) goto L50 (error at :41) else goto L25 +L25: + r60 = builtins :: module + r61 = 'staticmethod' + r62 = CPyObject_GetAttr(r60, r61) + if is_error(r62) goto L51 (error at :41) else goto L26 +L26: + r63 = [r59] + r64 = load_address r63 + r65 = PyObject_Vectorcall(r62, r64, 1, 0) + dec_ref r62 + if is_error(r65) goto L51 (error at :41) else goto L27 +L27: + dec_ref r59 + r66 = '__new__' + r67 = CPyDict_SetItem(r56, r66, r65) + dec_ref r65 + r68 = r67 >= 0 :: signed + if not r68 goto L50 (error at :41) else goto L28 :: bool +L28: + r69 = __getitem___HexBytes_obj() + if is_error(r69) goto L50 (error at :53) else goto L29 +L29: + r70 = '__getitem__' + r71 = CPyDict_SetItem(r56, r70, r69) + dec_ref r69 + r72 = r71 >= 0 :: signed + if not r72 goto L50 (error at :53) else goto L30 :: bool +L30: + r73 = __repr___HexBytes_obj() + if is_error(r73) goto L50 (error at :62) else goto L31 +L31: + r74 = '__repr__' + r75 = CPyDict_SetItem(r56, r74, r73) + dec_ref r73 + r76 = r75 >= 0 :: signed + if not r76 goto L50 (error at :62) else goto L32 :: bool +L32: + r77 = to_0x_hex_HexBytes_obj() + if is_error(r77) goto L50 (error at :65) else goto L33 +L33: + r78 = 'to_0x_hex' + r79 = CPyDict_SetItem(r56, r78, r77) + dec_ref r77 + r80 = r79 >= 0 :: signed + if not r80 goto L50 (error at :65) else goto L34 :: bool +L34: + r81 = __reduce___HexBytes_obj() + if is_error(r81) goto L50 (error at :71) else goto L35 +L35: + r82 = '__reduce__' + r83 = CPyDict_SetItem(r56, r82, r81) + dec_ref r81 + r84 = r83 >= 0 :: signed + if not r84 goto L50 (error at :71) else goto L36 :: bool +L36: + r85 = 'HexBytes' + r86 = '__annotations__' + r87 = CPyDict_SetItem(r56, r86, r58) + dec_ref r58 + r88 = r87 >= 0 :: signed + if not r88 goto L49 (error at :30) else goto L37 :: bool +L37: + r89 = 'mypyc filler docstring' + r90 = '__doc__' + r91 = CPyDict_SetItem(r56, r90, r89) + r92 = r91 >= 0 :: signed + if not r92 goto L49 (error at :30) else goto L38 :: bool +L38: + r93 = 'faster_hexbytes.main' + r94 = '__module__' + r95 = CPyDict_SetItem(r56, r94, r93) + r96 = r95 >= 0 :: signed + if not r96 goto L49 (error at :30) else goto L39 :: bool +L39: + r97 = [r85, r44, r56] + r98 = load_address r97 + r99 = PyObject_Vectorcall(r46, r98, 3, 0) + if is_error(r99) goto L49 (error at :30) else goto L40 +L40: + dec_ref r56 + dec_ref r44 + r100 = faster_hexbytes.main.globals :: static + r101 = 'mypyc_attr' + r102 = CPyDict_GetItem(r100, r101) + if is_error(r102) goto L52 (error at :29) else goto L41 +L41: + r103 = box(bool, 0) + r104 = [r103] + r105 = load_address r104 + r106 = ('native_class',) + r107 = PyObject_Vectorcall(r102, r105, 0, r106) + dec_ref r102 + if is_error(r107) goto L52 (error at :29) else goto L42 +L42: + r108 = [r99] + r109 = load_address r108 + r110 = PyObject_Vectorcall(r107, r109, 1, 0) + dec_ref r107 + if is_error(r110) goto L52 (error at :30) else goto L43 +L43: + dec_ref r99 + faster_hexbytes.main.HexBytes = r110 :: type + r111 = faster_hexbytes.main.globals :: static + r112 = 'HexBytes' + r113 = PyDict_SetItem(r111, r112, r110) + dec_ref r110 + r114 = r113 >= 0 :: signed + if not r114 goto L45 (error at :30) else goto L44 :: bool +L44: + r115 = faster_hexbytes.main.HexBytes :: type + return 1 +L45: + r116 = :: None + return r116 +L46: + dec_ref r23 + goto L45 +L47: + dec_ref r23 + dec_ref r27 + goto L45 +L48: + dec_ref r44 + goto L45 +L49: + dec_ref r44 + dec_ref r56 + goto L45 +L50: + dec_ref r44 + dec_ref r56 + dec_ref r58 + goto L45 +L51: + dec_ref r44 + dec_ref r56 + dec_ref r58 + dec_ref r59 + goto L45 +L52: + dec_ref r99 + goto L45 + +def to_bytes(val): + val :: union[bool, object, bytes, int, str] + 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:15) 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:17) else goto L5 +L5: + r4 = hexstr_to_bytes(r3) + dec_ref r3 + if is_error(r4) goto L51 (error at to_bytes:17) 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:19) else goto L9 +L9: + r10 = cast(bytes, r9) + if is_error(r10) goto L51 (error at to_bytes:19) 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:21) 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:25) 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:26) else goto L25 +L25: + r27 = CPyTagged_Str(r26) + dec_ref r26 :: int + if is_error(r27) goto L51 (error at to_bytes:26) 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:26) else goto L27 +L27: + r30 = builtins :: module + r31 = 'ValueError' + r32 = CPyObject_GetAttr(r30, r31) + if is_error(r32) goto L52 (error at to_bytes:26) 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:26) else goto L29 +L29: + dec_ref r29 + CPy_Raise(r35) + dec_ref r35 + if not 0 goto L51 (error at to_bytes:26) else goto L30 :: bool +L30: + unreachable +L31: + r36 = unbox(int, val) + if is_error(r36) goto L51 (error at to_bytes:28) else goto L32 +L32: + r37 = builtins :: module + r38 = 'hex' + r39 = CPyObject_GetAttr(r37, r38) + if is_error(r39) goto L53 (error at to_bytes:28) 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:28) else goto L34 +L34: + dec_ref r40 + r44 = cast(str, r43) + if is_error(r44) goto L51 (error at to_bytes:28) else goto L35 +L35: + r45 = to_bytes(r44) + dec_ref r44 + if is_error(r45) goto L51 (error at to_bytes:28) 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:29) 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:29) 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:30) else goto L41 +L41: + r56 = cast(bytes, r55) + if is_error(r56) goto L51 (error at to_bytes:30) 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:32) 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:32) else goto L45 +L45: + dec_ref r67 + r73 = ' to bytes' + r74 = PyList_New(5) + if is_error(r74) goto L56 (error at to_bytes:32) 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:32) else goto L47 +L47: + r82 = builtins :: module + r83 = 'TypeError' + r84 = CPyObject_GetAttr(r82, r83) + if is_error(r84) goto L57 (error at to_bytes:32) 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:32) else goto L49 +L49: + dec_ref r81 + CPy_Raise(r87) + dec_ref r87 + if not 0 goto L51 (error at to_bytes:32) 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 :: str + r32 :: object + r33 :: object[1] + r34 :: object_ptr + r35 :: object + r36, r37 :: 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 L29 (error at hexstr_to_bytes:36) else goto L1 +L1: + if r4 goto L2 else goto L5 :: bool +L2: + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L29 (error at hexstr_to_bytes:37) else goto L3 +L3: + r6 = cast(str, r5) + if is_error(r6) goto L29 (error at hexstr_to_bytes:37) 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 L30 (error at hexstr_to_bytes:42) else goto L7 :: bool +L7: + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L30 (error at hexstr_to_bytes:42) 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 L29 (error at hexstr_to_bytes:43) 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:48) else goto L31 +L13: + goto L25 +L14: + r15 = CPy_CatchError() + r16 = builtins :: module + r17 = 'UnicodeDecodeError' + r18 = CPyObject_GetAttr(r16, r17) + if is_error(r18) goto L32 (error at hexstr_to_bytes:49) else goto L15 +L15: + r19 = CPy_ExceptionMatches(r18) + dec_ref r18 + if r19 goto L16 else goto L33 :: 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:51) else goto L17 +L17: + r23 = builtins :: module + r24 = 'ValueError' + r25 = CPyObject_GetAttr(r23, r24) + if is_error(r25) goto L34 (error at hexstr_to_bytes:50) 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 L34 (error at hexstr_to_bytes:50) else goto L19 +L19: + dec_ref r22 + CPy_Raise(r28) + dec_ref r28 + if not 0 goto L23 (error at hexstr_to_bytes:50) else goto L35 :: bool +L20: + unreachable +L21: + CPy_Reraise() + if not 0 goto L23 else goto L36 :: bool +L22: + unreachable +L23: + CPy_RestoreExcInfo(r15) + dec_ref r15 + r29 = CPy_KeepPropagating() + if not r29 goto L29 else goto L24 :: bool +L24: + unreachable +L25: + r30 = binascii :: module + r31 = 'unhexlify' + r32 = CPyObject_GetAttr(r30, r31) + if is_error(r32) goto L37 (error at hexstr_to_bytes:54) else goto L26 +L26: + r33 = [r14] + r34 = load_address r33 + r35 = PyObject_Vectorcall(r32, r34, 1, 0) + dec_ref r32 + if is_error(r35) goto L37 (error at hexstr_to_bytes:54) else goto L27 +L27: + dec_ref r14 + r36 = cast(bytes, r35) + if is_error(r36) goto L29 (error at hexstr_to_bytes:54) else goto L28 +L28: + return r36 +L29: + r37 = :: bytes + return r37 +L30: + dec_ref non_prefixed_hex + goto L29 +L31: + dec_ref padded_hex + goto L13 +L32: + dec_ref padded_hex + goto L23 +L33: + dec_ref padded_hex + goto L21 +L34: + dec_ref r22 + goto L23 +L35: + dec_ref r15 + goto L20 +L36: + dec_ref r15 + goto L22 +L37: + dec_ref r14 + goto L29 + +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 :: object + r19 :: 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 L6 (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 L6 else goto L4 :: bool +L4: + r15 = ('Union',) + r16 = 'typing' + r17 = faster_hexbytes._utils.globals :: static + r18 = CPyImport_ImportFromMany(r16, r15, r15, r17) + if is_error(r18) goto L6 (error at :2) else goto L5 +L5: + typing = r18 :: module + dec_ref r18 + return 1 +L6: + r19 = :: None + return r19 + +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 diff --git a/build/temp.linux-x86_64-cpython-313/build/__native_6a32f4913d613d6a7ddf.o b/build/temp.linux-x86_64-cpython-313/build/__native_6a32f4913d613d6a7ddf.o new file mode 100644 index 0000000000000000000000000000000000000000..1907731f39aa85a2d9082a8983b6ca9763541e53 GIT binary patch literal 342400 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 EAAG~M2LJ#7 literal 0 HcmV?d00001 diff --git a/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes.o b/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes.o new file mode 100644 index 0000000000000000000000000000000000000000..bd807a3eac9d395a8928f92ae5e1e99f74e5fddd GIT binary patch literal 5296 zcmbtYU2Gdw7QWZxAx_;oX#+H+TjD@LQ1CcTLYhJguACCLu+$U+DSu{ck7I*9V~xku zUJxKcK~Yty+I?89v=2yh-`G`!Kw@83S$@-DSx@tvt9ERT z9et;}F2DE{D9tfv2l~4#zxd|x{STf$GcYm(JuH19d-}Gsj4hev`yYIxdLqAcF26Lh zJtiFi_x0=5sx~n4ERKbp!0~>G+>|~sUY*>PnW#+Rr|+y(s>Ncn*Xos7-K;yss@`@C zyI3>2rJiH7(FW*e%(PImZ@@@pJch<97Td7!)8Bo9So-zKrU+un=*2>wjtmPqIx&0^ z;{1|9tdRQMit#`9A;+WM-ktPXJ^?Oq}cwz166M!uAmWe_P#Vu6M`rVO%?xpI+`&4dY8Do(spI5gWjz-iC%BPXo z0T)tEM|Z3Jcc`%gQLen#omV%z8XreK_Y@9z3Lkc>Dt|!TV1So?K&>}tb0l1x<#`*Tq0?Vee# z*_LT_+Nq9tq;6JHj$UdQZD?#edil{*%eEY&>{vEBu}p9-8_Es6U8Cl@WkN%_>XTWa zw?FJ)7kURvkATPGtl{i+9Q!U9o4EkmIla~HGz`QGR^5bbz;F%rxA!-jmhI>b@>nd2 zqhCb1*@C8`Tm9CmfIXnanSHrK`)+0Fn$Q~T^n?amwlm$GnoQTta-&l*(k;<~4QzF44cj6ZcJV?SL&EfM}|jgsw2elC&wqXvB_&CjHf{456otG5+JDX zG%jN<2sZ68Hv+;ccDX| zvu@?B13fTlFHoOyHL4CueHxDx*%gvOecbomQocHXKP=@P0UYxN(xh8?@$-U|F%Kb; z|Ce16e$BW<_?uGB1#nuId;tGY%7MXz;q-ues;Pq0;HXd8itlPS| z0Ka3ThHWl1>TL%*xZt8uHw{vN4v9s$DCDx$Y#JsE(1b^r1{XFw!r)ORN4^}hxWDA1rhM7aK#*QtM6|Azq!>;Fz^_g855Q&6`JjX@0c z|0C_k{Kg@=CSYOXpO%T5>~Z{*bI>J?{~6%J`qyMY1phk_)cxZc_P0sL%bIevfqI3pc7_q$|ve)!pnt%?5O_78ukU5 z5b%8YiR`F84UNS6^_~bO6xkTmeIIa)OBpVni>IZ1(nDN^){kI(kD$+>{R`5*MvAfy z+J6Oj*#2d4vw&z{F#hn)Cwq#&u)fhQhLZw1B_|C3Z4qyepgpF^VD3V@*Q6rGr=NoB Sw-Fk{>|1jDl*h literal 0 HcmV?d00001 diff --git a/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/_utils.o b/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/_utils.o new file mode 100644 index 0000000000000000000000000000000000000000..7ddfb93457e2ef5222e2e705b143a120055f2dea GIT binary patch literal 5296 zcmbtYU2Gf25#HtTBFdC0*-m0Qt|O{Q(!?;2qNK{QW5+ZoN3@Z~suMMG5|=%aN0AA6 zM;wnfS+q$JRRshifY3Yy1^O2EEiL@eqUcMZG%egd^d&(4fFN;!0CCb7ZqcWv0o<9r zozrPe1x-3IZ)U!onVsF8ojdvY6OTL`;hYh1_7L092xY95*pPEV%&|Qz$^JEb_h$=* z7mp(JSYi3o4fg%`gmNcn*Xos7-L8AZ zs@e7|w^*~frJiTCi$EQ(-e{xq7rGl??EWcu>x{=RijI$c_z2VQLW($xA#G;_F>UO2 zq0dB;LXS=+Z$q5lF@g+f&}WSQd;ldL4G!~CF!BLNF?@uH59+@LUHd2mY9tTdVm+j9 zvW$`?6Vj{Ny@HqdJ&YUd*d8r$cr5auekguq4`UID#2<|NfVPiickSRi2NuU7XU8rN zJTV5#h#D;LN{vA(`VM|?Vpm)n-8+i5BfA;9EgT8KT#~T?gNq48cpv1uV8#1*cGnrc zuzN9nHvU8$p~1}%tlmPGG%_p-LL8ZRh*bQC&e@=!8Q9*b?|4$@E{OI%Z*>>--M+>9kq-ldQ-Q&|-Kx%?*0);_Wl;OY zfEVR@OnbBYg3gNqx-{@AK=)}^yRi@T%&7=eFfY#cinEs4XgFmy_vk_@pFNn$P8yTO zcq-lWI<|Fm$+9iCUIx{4%eAB3nd$WOR4Tm$|FWs{=}G@rwVia^13NG6oVVO+!?}=3 zSLaXW;c2#ecDd#{w$o{+JNAXTT}gXpsbRHYuJR0}K~?vVF4IbX?DD zfXzv462+pp>_ya@Ef^~L>|0I+`~fY_p2(j$@o-@8w~$h&-l$}h4wLcwi&18on$xs0 zZpVh*%Up2WXEW4=0^xtM={pU}I4uumfbLfD9H&t>%QY)A-}7pYotZS?01sxm(^Hwc zU2b$LR;DFJaDW8~27)8@&!{nIoBp1GTo*e50-MX{52x;5D0OVFBTFMa-4W` z_|yXu#v6cyZ3CMbUIeHqyo~FJ(N(z}WF-FmGmLjf_}-y`*c#lGDZsuaMi{$<{6u2p zCy_!Txvb45#v|X|mPj5?j2utI=HlN5IWOdVoMF7jr62W9srF@fEu-w8H~S50eczmz zyXeKYxM)GQ-aMqSq0NBQG`4*Ue0U2ycr66u+k_>kq(Ohb#ao6T!Ljk} z46Rq}Ibh#_->tJUh93z1aNPTTczp}J131om88}jKWZj!fzTe$hVTav1VVfK^dh`~AQ0Ne;Yav9 zfr$t)z&xop;}F&u66ND-5KjtdkM)q3`h5z%B=!9Y{zIux zDfn-ten`RBrT&nD|3&IFKjrg=#0!f3`%*t6xw@{D#Ia_>b-SqGR42@6_nPnl1KfiT z3FI}BT&rOkp4Ii3Q87J}8Kric8Lop0nr98@X<>B+RP?D>rOpz3iBui%6tY<=xz_nj z!=`K6OBMw5EnIu4QEz)V!A6Ki-L}X8CL|HzqR`7uvuW9opbg(#2E3r*n+v|dq`qW# z4EP#rS+3WUajjah>Y7bUZpZ)4QV;>pfa;F|=A=OPfpDrv()WUZ{VPX+lcfsEkg0Nl@57#^n{2L#A2yMf302GY*RsFNzi!mqQ7bcqja2N!c<|m$$nCd?x z4OD+xKlx+7AQ{AfTnYXoKzu>9#lG5a|L@0(2s9!u5$-?sA)24||9gO`F#%#F>Gw-i zLZsT_pYJM$=EL$p#zVd+sAFh9Vx2yaA3SbzM)(N7ZBN!CuureX3#D4`g{ru0%PtuP> zl#K`Z5&!)b{^w*v!21;@@*{o)21yRvt*Q-04yv|q1CDhm%Pk18CjCEM!zI33h1(2@NST?BvgNFld{x6 d+Mqv6!<7w4Nb3IW0JNWfOXg2~jKZk?{{`I{k&FNU literal 0 HcmV?d00001 diff --git a/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/main.o b/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/main.o new file mode 100644 index 0000000000000000000000000000000000000000..41dc0be36002681a3541b61a8b812b5d299ead6d GIT binary patch literal 5280 zcmbVPZ){uD6~EWdk2rPWq%ET^U5Ud0K~+D;NtULC4o6OjTLH~lGEx|GpY7+^V87=* zKT~^~1|xJ*R3TO41DdoCljy#&sUL;}(lmv2Q@_BMN!yr&ph!p*M%7LGv<;~{=iYl> zUS1uvaTLFM&hPxW=iYnnc`wf$dHA6S=ZuK6Z?FxCP{vLtHu#)ib8I(DvVV@;@$aR= zONS9USy=rnc@??B*>&&f!b@Kl{MzNh+9e6E{h@G9JGn(10+9W~kYC!e}hJzrS6 zURayIE2aVg_qX3wtH#LKiLkNJLr+>ALjS)D$ZovO^>&pc46REx!CuhlEFx?T5* zRkQ6`Zn0){OFhqO7eQ&(ZFEKY0(aw!+&=?fo$(mP(DAVsA3=IEAc&I~(so1;)5dQV z@@yn2tH)9cn#P5$wK-)7JaN5JV0)Xs{Ry4B_>8eglrQVM zPemj8u=Zgjc1%Lr<>&+Y;G=r%Sd?pj?k?-Qq{aJ@k9>n;zQJF+Rh@rZAGRRMp!SOa zFUs|p_NVR(Ixh<7!oX_)-J@OU#y-+B$0AU{ytvpa&Rb@q;gs3Jqf4oL_CP8-WlR|p zsdUrp*w*0{%eLHl8AQ`9*A91QXVNp%sq_l`WmD@#({lJ?9}!)k-F?V06g(k<8Vtg`307{sw5xKflGX1hk} zx?_W)Tn)%?-my#jFFY_&TL3-Lv#ZbKJfxY(oZqs^w{dS(M` zj$(@_7R6OBqTFnOswjs?oC^2@TAV+UKXK$CvKI}c)TuWrnNWAhpvow-OwDOp8MkA@ z&SlOx?lT$cKR)w6+4P-+Wt^4=GeBRfc#hL3o8_97S?qZ=$IeU{aCiqY-I?i3-7Yse z6)V#c8dNZqo*EpnZ$^zlvy^)Ud|m7SFl-^8Ka{$6snoH(jw*@tOh<^5Kb)L4CZ_LG zFx+#fXKY_s`cOr9{ninq%W*64Nc?*z81IhqJwpSr^Kd(+0sE@ZFm?gQBZ<);M+%AL zsy3gPh5FZg_%VZ6tbA9YJ5_8ssdM%h1Z^iyhm-;|iU=)O0( zXnud*tkT%fWg_&_xF&LI|L)%D+GxV+AZ4=Sg+V~ zz`h2*n`dS0;1>Ae7Pz$q{$0Rv-it6I`Ddm|(ResN!Qhd_$KG&@SY|fb5=QkwDeU$Z$drkNq$`9?g1@QY6j)Ek-%=x*VV+cnb%kS|n9qI{ zr=@VRS0XzX!Y7pcvKlcC-cs7nR~1fi$eun$2&Z25RwxekIiz>w;O{fpUr{*ae@u3E_C}k@m^Kuaoa9c{+qsy<&es zqWHg&BK-FviSSEG&WG@~m0SqnR6i#a9$r^U;aCg7x?K+87nRJ6cCQJaEHHZT>40O6 zIM-^JhG%s>W>ieiWJamoW`^safaX~Px>``21rdEJR;jZB-yT&5JOyu-O0M1V9lfIU-;-lXd9&cAYjZd>z@T*j5!IvAkqA@K@fPFpT?ZR!v3?$AnZ@; zCx7f0!~^S7OM!p)5y^yYv9I>q|0G^epiy;+aR0I2(EPOjrvVGc1c;qhe!oN^Kw;Z9 z=)xG9532*22>2o!w#9$=`{jSHYSiS9`BTrqIF$bjz=va^{;-;#-iL@Gg>7HygQ49M z%Kr)q0Sf#71a$rKUsn0Qt9&tke7A@9|5d;+Can`#L5DCX5Y>^CHu9%Deg%qt{w}`k zfIgIi|0F*ee+!y^{wGyK!21;>@}u!GD2Wf+Jr`~$N*T8O3*cCns@(h#&ny3wk4T30 zkKpUTV9c=p&y|0T4AmI+{}k|k=Qn|e1w`k9=ZEin@~8UiH#hpla8W=P)q?T+9!nzZ kk8M(w8gLu*hBExo1|&EY&PTTc*U$g7%AfieIfVWH3oqV@6aWAK literal 0 HcmV?d00001 From d0c74e89091533843ffb8d1ff62c27454df163c2 Mon Sep 17 00:00:00 2001 From: BobTheBuidler Date: Tue, 30 Sep 2025 04:31:46 +0000 Subject: [PATCH 18/70] comiple --- faster_hexbytes/_utils.py | 8 ++++++-- faster_hexbytes/main.py | 16 ++++++++++------ pyproject.toml | 2 +- setup.py | 8 ++++++-- tests/core/test_import_and_version.py | 2 +- 5 files changed, 24 insertions(+), 12 deletions(-) diff --git a/faster_hexbytes/_utils.py b/faster_hexbytes/_utils.py index 5551728..991307f 100644 --- a/faster_hexbytes/_utils.py +++ b/faster_hexbytes/_utils.py @@ -1,10 +1,14 @@ 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)` . @@ -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 index b987a6c..88c3944 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -1,12 +1,14 @@ from typing import ( TYPE_CHECKING, Callable, + Final, Tuple, Type, Union, overload, ) +import hexbytes from mypy_extensions import ( mypyc_attr, ) @@ -23,11 +25,13 @@ SupportsIndex, ) -BytesLike = Union[bool, bytearray, bytes, int, str, memoryview] +BytesLike = Union[bytes, str, bool, bytearray, int, memoryview] + +_bytes_new: Final = bytes.__new__ @mypyc_attr(native_class=False) -class HexBytes(bytes): +class HexBytes(hexbytes.HexBytes): """ Thin wrapper around the python built-in :class:`bytes` class. @@ -40,7 +44,7 @@ class HexBytes(bytes): def __new__(cls, val: BytesLike) -> Self: bytesval = to_bytes(val) - return bytes.__new__(cls, bytesval) + return _bytes_new(cls, bytesval) @overload def __getitem__(self, key: "SupportsIndex") -> int: # noqa: F811 @@ -53,7 +57,7 @@ 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) + result = bytes.__getitem__(self, key) if hasattr(result, "hex"): return type(self)(result) else: @@ -66,7 +70,7 @@ def to_0x_hex(self) -> str: """ Convert the bytes to a 0x-prefixed hex string """ - return "0x" + self.hex() + return f"0x{self.hex()}" def __reduce__( self, @@ -76,4 +80,4 @@ def __reduce__( ``HexBytes.__new__`` since an existing HexBytes instance has already been validated when created. """ - return bytes.__new__, (type(self), bytes(self)) + return _bytes_new, (type(self), bytes(self)) diff --git a/pyproject.toml b/pyproject.toml index 2edc694..0515243 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,5 @@ [build-system] -requires = ["setuptools", "wheel", "mypy[mypyc]>=1.14.1,<1.18.3"] +requires = ["setuptools", "wheel", "mypy[mypyc]==1.18.2", "hexbytes==1.3.1"] build-backend = "setuptools.build_meta" [tool.autoflake] diff --git a/setup.py b/setup.py index 83cea33..11d4714 100644 --- a/setup.py +++ b/setup.py @@ -6,6 +6,9 @@ ) from mypyc.build import mypycify + +version = "1.3.1" + extras_require = { "dev": [ "build>=0.9.0", @@ -46,10 +49,11 @@ # we can't compile on python3.8 but we can still let the user install ext_modules = [] + setup( name="faster_hexbytes", # *IMPORTANT*: Don't manually change the version here. See Contributing docs for the release process. - version="1.3.1", + 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", @@ -57,7 +61,7 @@ author_email="snakecharmers@ethereum.org", url="https://github.com/ethereum/hexbytes", include_package_data=True, - install_requires=[], + install_requires=[f"hexbytes=={version}"], python_requires=">=3.8, <4", extras_require=extras_require, py_modules=["faster_hexbytes"], diff --git a/tests/core/test_import_and_version.py b/tests/core/test_import_and_version.py index 84b61da..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 faster_hexbytes - assert isinstance(hexbytes.__version__, str) + assert isinstance(faster_hexbytes.__version__, str) From 8872a62a2970259ee32be5a903b2b746c620c1c4 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 00:44:50 -0400 Subject: [PATCH 19/70] microoptimize __getitem__ --- faster_hexbytes/main.py | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index 88c3944..476454a 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -16,7 +16,7 @@ Self, ) -from ._utils import ( +from faster_hexbytes._utils import ( to_bytes, ) @@ -51,17 +51,20 @@ def __getitem__(self, key: "SupportsIndex") -> int: # noqa: F811 ... @overload # noqa: F811 - def __getitem__(self, key: slice) -> "HexBytes": # noqa: F811 + def __getitem__(self, key: slice) -> Self: # noqa: F811 ... def __getitem__( # noqa: F811 self, key: Union["SupportsIndex", slice] - ) -> Union[int, bytes, "HexBytes"]: + ) -> Union[int, Self]: result = bytes.__getitem__(self, key) - if hasattr(result, "hex"): - return type(self)(result) - else: + 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) + return cls(result) def __repr__(self) -> str: return f"HexBytes({'0x' + self.hex()!r})" From 3570529d8585f370af06b154970a4c257507a4fe Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 00:45:43 -0400 Subject: [PATCH 20/70] fix compile err --- faster_hexbytes/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faster_hexbytes/__init__.py b/faster_hexbytes/__init__.py index bf32717..dbacf8e 100644 --- a/faster_hexbytes/__init__.py +++ b/faster_hexbytes/__init__.py @@ -2,7 +2,7 @@ version as __version, ) -from .main import ( +from faster_hexbytes.main import ( HexBytes, ) From df3e297fc68836cacbaaf113b865b43525831b6d Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 00:46:13 -0400 Subject: [PATCH 21/70] Update .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index c3a466e..85311be 100644 --- a/.gitignore +++ b/.gitignore @@ -9,6 +9,7 @@ dist build/**/*.py build/**/*.typed +build/**/*.o .build eggs .eggs From cbcc7b6f157b539b2b5ba9dd203e3f5497a1430c Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 00:46:38 -0400 Subject: [PATCH 22/70] Delete build directory --- build/__native_6a32f4913d613d6a7ddf.c | 2975 ----------------- build/__native_6a32f4913d613d6a7ddf.h | 72 - .../__native_internal_6a32f4913d613d6a7ddf.h | 75 - build/faster_hexbytes.c | 21 - build/faster_hexbytes/_utils.c | 21 - build/faster_hexbytes/main.c | 21 - build/ops.txt | 1375 -------- .../build/__native_6a32f4913d613d6a7ddf.o | Bin 342400 -> 0 bytes .../build/faster_hexbytes.o | Bin 5296 -> 0 bytes .../build/faster_hexbytes/_utils.o | Bin 5296 -> 0 bytes .../build/faster_hexbytes/main.o | Bin 5280 -> 0 bytes 11 files changed, 4560 deletions(-) delete mode 100644 build/__native_6a32f4913d613d6a7ddf.c delete mode 100644 build/__native_6a32f4913d613d6a7ddf.h delete mode 100644 build/__native_internal_6a32f4913d613d6a7ddf.h delete mode 100644 build/faster_hexbytes.c delete mode 100644 build/faster_hexbytes/_utils.c delete mode 100644 build/faster_hexbytes/main.c delete mode 100644 build/ops.txt delete mode 100644 build/temp.linux-x86_64-cpython-313/build/__native_6a32f4913d613d6a7ddf.o delete mode 100644 build/temp.linux-x86_64-cpython-313/build/faster_hexbytes.o delete mode 100644 build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/_utils.o delete mode 100644 build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/main.o diff --git a/build/__native_6a32f4913d613d6a7ddf.c b/build/__native_6a32f4913d613d6a7ddf.c deleted file mode 100644 index 136c015..0000000 --- a/build/__native_6a32f4913d613d6a7ddf.c +++ /dev/null @@ -1,2975 +0,0 @@ -#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[3]; /* '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[67]; /* ('version',) */ - cpy_r_r6 = CPyStatics[68]; /* ('__version',) */ - cpy_r_r7 = CPyStatics[6]; /* '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", "", 1, 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[69]; /* ('HexBytes',) */ - cpy_r_r11 = CPyStatics[8]; /* '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", "", 5, 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[7]; /* 'HexBytes' */ - cpy_r_r15 = PyList_New(1); - if (unlikely(cpy_r_r15 == NULL)) { - CPy_AddTraceback("faster_hexbytes/__init__.py", "", 9, 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[9]; /* '__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", "", 9, CPyStatic_faster_hexbytes___globals); - goto CPyL12; - } - cpy_r_r22 = CPyStatics[10]; /* 'hexbytes' */ - cpy_r_r23 = CPyStatic_faster_hexbytes___globals; - cpy_r_r24 = CPyStatics[5]; /* '__version' */ - cpy_r_r25 = CPyDict_GetItem(cpy_r_r23, cpy_r_r24); - if (unlikely(cpy_r_r25 == NULL)) { - CPy_AddTraceback("faster_hexbytes/__init__.py", "", 11, 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", "", 11, 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[11]; /* '__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", "", 11, 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); - 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", 15, 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", 17, 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", 17, 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", 19, 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", 19, 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", 21, CPyStatic__utils___globals); - goto CPyL51; - } - if (!cpy_r_r12) goto CPyL15; - cpy_r_r13 = CPyStatics[65]; /* b'\x01' */ - CPy_INCREF(cpy_r_r13); - cpy_r_r14 = cpy_r_r13; - goto CPyL16; -CPyL15: ; - cpy_r_r15 = CPyStatics[66]; /* 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", 25, 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[12]; /* '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", 26, 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", 26, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r28 = CPyStatics[13]; /* ' 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", 26, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r30 = CPyModule_builtins; - cpy_r_r31 = CPyStatics[14]; /* '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", 26, 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", 26, 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", 26, 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", 28, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r37 = CPyModule_builtins; - cpy_r_r38 = CPyStatics[15]; /* '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", 28, 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", 28, 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", 28, 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", 28, CPyStatic__utils___globals); - goto CPyL51; - } - return cpy_r_r45; -CPyL37: ; - cpy_r_r46 = CPyModule_builtins; - cpy_r_r47 = CPyStatics[16]; /* '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", 29, 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", 29, 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", 30, 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", 30, CPyStatic__utils___globals, "bytes", cpy_r_r55); - goto CPyL51; - } - return cpy_r_r56; -CPyL43: ; - cpy_r_r57 = CPyStatics[17]; /* '' */ - cpy_r_r58 = CPyStatics[18]; /* 'Cannot convert ' */ - cpy_r_r59 = CPyStatics[19]; /* '{!r:{}}' */ - cpy_r_r60 = CPyStatics[17]; /* '' */ - cpy_r_r61 = CPyStatics[20]; /* '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", 32, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r65 = CPyStatics[21]; /* ' of type ' */ - cpy_r_r66 = CPyStatics[22]; /* '{:{}}' */ - cpy_r_r67 = CPy_TYPE(cpy_r_val); - cpy_r_r68 = CPyStatics[17]; /* '' */ - cpy_r_r69 = CPyStatics[20]; /* '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", 32, CPyStatic__utils___globals); - goto CPyL55; - } - CPy_DECREF(cpy_r_r67); - cpy_r_r73 = CPyStatics[13]; /* ' to bytes' */ - cpy_r_r74 = PyList_New(5); - if (unlikely(cpy_r_r74 == NULL)) { - CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 32, 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", 32, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r82 = CPyModule_builtins; - cpy_r_r83 = CPyStatics[23]; /* '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", 32, 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", 32, 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", 32, 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 (PyBool_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 (PyBytes_Check(obj_val) || PyByteArray_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; - if (PyUnicode_Check(obj_val)) - arg_val = obj_val; - else { - arg_val = NULL; - } - if (arg_val != NULL) goto __LL1; - CPy_TypeError("union[bool, object, bytes, int, str]", obj_val); - goto fail; -__LL1: ; - PyObject *retval = CPyDef__utils___to_bytes(arg_val); - return retval; -fail: ; - CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 7, 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; - PyObject *cpy_r_r31; - PyObject *cpy_r_r32; - PyObject **cpy_r_r34; - PyObject *cpy_r_r35; - PyObject *cpy_r_r36; - PyObject *cpy_r_r37; - cpy_r_r0 = CPyStatics[24]; /* '0x' */ - cpy_r_r1 = CPyStatics[25]; /* '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", 36, CPyStatic__utils___globals); - goto CPyL29; - } - 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", 37, CPyStatic__utils___globals); - goto CPyL29; - } - if (likely(PyUnicode_Check(cpy_r_r5))) - cpy_r_r6 = cpy_r_r5; - else { - CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 37, CPyStatic__utils___globals, "str", cpy_r_r5); - goto CPyL29; - } - 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", 42, CPyStatic__utils___globals); - goto CPyL30; - } - 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", 42, CPyStatic__utils___globals); - goto CPyL30; - } - cpy_r_r11 = cpy_r_r10 != 0; - CPyTagged_DECREF(cpy_r_r10); - if (!cpy_r_r11) goto CPyL11; - cpy_r_r12 = CPyStatics[26]; /* '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", 43, CPyStatic__utils___globals); - goto CPyL29; - } - 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", 48, CPyStatic__utils___globals); - goto CPyL14; - } else - goto CPyL31; -CPyL13: ; - goto CPyL25; -CPyL14: ; - cpy_r_r15 = CPy_CatchError(); - cpy_r_r16 = CPyModule_builtins; - cpy_r_r17 = CPyStatics[27]; /* '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", 49, CPyStatic__utils___globals); - goto CPyL32; - } - cpy_r_r19 = CPy_ExceptionMatches(cpy_r_r18); - CPy_DecRef(cpy_r_r18); - if (!cpy_r_r19) goto CPyL33; - cpy_r_r20 = CPyStatics[28]; /* 'hex string ' */ - cpy_r_r21 = CPyStatics[29]; /* ' 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", 51, CPyStatic__utils___globals); - goto CPyL23; - } - cpy_r_r23 = CPyModule_builtins; - cpy_r_r24 = CPyStatics[14]; /* '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", 50, CPyStatic__utils___globals); - goto CPyL34; - } - 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", 50, CPyStatic__utils___globals); - goto CPyL34; - } - 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", 50, CPyStatic__utils___globals); - goto CPyL23; - } else - goto CPyL35; -CPyL20: ; - CPy_Unreachable(); -CPyL21: ; - CPy_Reraise(); - if (!0) { - goto CPyL23; - } else - goto CPyL36; -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 CPyL29; - CPy_Unreachable(); -CPyL25: ; - cpy_r_r30 = CPyModule_binascii; - cpy_r_r31 = CPyStatics[30]; /* 'unhexlify' */ - cpy_r_r32 = CPyObject_GetAttr(cpy_r_r30, cpy_r_r31); - if (unlikely(cpy_r_r32 == NULL)) { - CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 54, CPyStatic__utils___globals); - goto CPyL37; - } - PyObject *cpy_r_r33[1] = {cpy_r_r14}; - 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", "hexstr_to_bytes", 54, CPyStatic__utils___globals); - goto CPyL37; - } - CPy_DECREF(cpy_r_r14); - if (likely(PyBytes_Check(cpy_r_r35) || PyByteArray_Check(cpy_r_r35))) - cpy_r_r36 = cpy_r_r35; - else { - CPy_TypeErrorTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 54, CPyStatic__utils___globals, "bytes", cpy_r_r35); - goto CPyL29; - } - return cpy_r_r36; -CPyL29: ; - cpy_r_r37 = NULL; - return cpy_r_r37; -CPyL30: ; - CPy_DecRef(cpy_r_non_prefixed_hex); - goto CPyL29; -CPyL31: ; - CPy_DECREF(cpy_r_padded_hex); - goto CPyL13; -CPyL32: ; - CPy_DecRef(cpy_r_padded_hex); - goto CPyL23; -CPyL33: ; - CPy_DecRef(cpy_r_padded_hex); - goto CPyL21; -CPyL34: ; - CPy_DecRef(cpy_r_r22); - goto CPyL23; -CPyL35: ; - CPy_DecRef(cpy_r_r15.f0); - CPy_DecRef(cpy_r_r15.f1); - CPy_DecRef(cpy_r_r15.f2); - goto CPyL20; -CPyL36: ; - CPy_DecRef(cpy_r_r15.f0); - CPy_DecRef(cpy_r_r15.f1); - CPy_DecRef(cpy_r_r15.f2); - goto CPyL22; -CPyL37: ; - CPy_DecRef(cpy_r_r14); - goto CPyL29; -} - -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", 35, 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; - char cpy_r_r19; - 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[3]; /* '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 CPyL6; - } - 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[71]; /* (('binascii', 'binascii', 'binascii'),) */ - cpy_r_r11 = CPyStatic__utils___globals; - cpy_r_r12 = CPyStatics[32]; /* 'faster_hexbytes/_utils.py' */ - cpy_r_r13 = CPyStatics[33]; /* '' */ - 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 CPyL6; - cpy_r_r15 = CPyStatics[72]; /* ('Union',) */ - cpy_r_r16 = CPyStatics[35]; /* '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", "", 2, CPyStatic__utils___globals); - goto CPyL6; - } - CPyModule_typing = cpy_r_r18; - CPy_INCREF(CPyModule_typing); - CPy_DECREF(cpy_r_r18); - return 1; -CPyL6: ; - cpy_r_r19 = 2; - return cpy_r_r19; -} - -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); - Py_CLEAR(CPyType_main___HexBytes); - 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; - PyObject *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__", 42, CPyStatic_main___globals); - goto CPyL4; - } - cpy_r_r1 = (PyObject *)&PyBytes_Type; - cpy_r_r2 = CPyStatics[36]; /* '__new__' */ - PyObject *cpy_r_r3[3] = {cpy_r_r1, cpy_r_cls, cpy_r_r0}; - cpy_r_r4 = (PyObject **)&cpy_r_r3; - cpy_r_r5 = PyObject_VectorcallMethod(cpy_r_r2, cpy_r_r4, 9223372036854775811ULL, 0); - if (unlikely(cpy_r_r5 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__new__", 43, CPyStatic_main___globals); - goto CPyL5; - } - CPy_DECREF(cpy_r_r0); - if (likely(Py_TYPE(cpy_r_r5) == CPyType_main___HexBytes)) - cpy_r_r6 = cpy_r_r5; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__new__", 43, CPyStatic_main___globals, "faster_hexbytes.main.HexBytes", cpy_r_r5); - goto CPyL4; - } - return cpy_r_r6; -CPyL4: ; - cpy_r_r7 = NULL; - return cpy_r_r7; -CPyL5: ; - CPy_DecRef(cpy_r_r0); - goto CPyL4; -} - -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 (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 (PyBytes_Check(obj_val) || PyByteArray_Check(obj_val)) - arg_val = obj_val; - else { - arg_val = NULL; - } - 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; - if (PyUnicode_Check(obj_val)) - arg_val = obj_val; - else { - arg_val = NULL; - } - if (arg_val != NULL) goto __LL4; - CPy_TypeError("union[bool, object, bytes, int, str]", 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__", 41, 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_r2; - PyObject *cpy_r_r3; - PyObject **cpy_r_r5; - PyObject *cpy_r_r6; - PyObject *cpy_r_r7; - PyObject *cpy_r_r8; - 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_r17; - PyObject *cpy_r_r18; - PyObject *cpy_r_r19; - CPyTagged cpy_r_r20; - PyObject *cpy_r_r21; - PyObject *cpy_r_r22; - cpy_r_r0 = CPyModule_builtins; - cpy_r_r1 = CPyStatics[37]; /* 'super' */ - cpy_r_r2 = CPyObject_GetAttr(cpy_r_r0, cpy_r_r1); - if (unlikely(cpy_r_r2 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals); - goto CPyL11; - } - cpy_r_r3 = (PyObject *)CPyType_main___HexBytes; - PyObject *cpy_r_r4[2] = {cpy_r_r3, cpy_r_self}; - cpy_r_r5 = (PyObject **)&cpy_r_r4; - cpy_r_r6 = PyObject_Vectorcall(cpy_r_r2, cpy_r_r5, 2, 0); - CPy_DECREF(cpy_r_r2); - if (unlikely(cpy_r_r6 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals); - goto CPyL11; - } - cpy_r_r7 = CPyStatics[38]; /* '__getitem__' */ - cpy_r_r8 = CPyObject_GetAttr(cpy_r_r6, cpy_r_r7); - CPy_DECREF(cpy_r_r6); - if (unlikely(cpy_r_r8 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals); - goto CPyL11; - } - PyObject *cpy_r_r9[1] = {cpy_r_key}; - cpy_r_r10 = (PyObject **)&cpy_r_r9; - cpy_r_r11 = PyObject_Vectorcall(cpy_r_r8, cpy_r_r10, 1, 0); - CPy_DECREF(cpy_r_r8); - if (unlikely(cpy_r_r11 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals); - goto CPyL11; - } - if (PyLong_Check(cpy_r_r11)) - cpy_r_r12 = cpy_r_r11; - else { - cpy_r_r12 = NULL; - } - if (cpy_r_r12 != NULL) goto __LL5; - if (PyBytes_Check(cpy_r_r11) || PyByteArray_Check(cpy_r_r11)) - cpy_r_r12 = cpy_r_r11; - else { - cpy_r_r12 = NULL; - } - if (cpy_r_r12 != NULL) goto __LL5; - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 56, CPyStatic_main___globals, "union[int, bytes]", cpy_r_r11); - goto CPyL11; -__LL5: ; - cpy_r_r13 = CPyStatics[15]; /* 'hex' */ - cpy_r_r14 = PyObject_HasAttr(cpy_r_r12, cpy_r_r13); - if (!cpy_r_r14) goto CPyL9; - cpy_r_r15 = CPy_TYPE(cpy_r_self); - PyObject *cpy_r_r16[1] = {cpy_r_r12}; - cpy_r_r17 = (PyObject **)&cpy_r_r16; - cpy_r_r18 = PyObject_Vectorcall(cpy_r_r15, cpy_r_r17, 1, 0); - CPy_DECREF(cpy_r_r15); - if (unlikely(cpy_r_r18 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 58, CPyStatic_main___globals); - goto CPyL12; - } - CPy_DECREF(cpy_r_r12); - if (likely(Py_TYPE(cpy_r_r18) == CPyType_main___HexBytes)) - cpy_r_r19 = cpy_r_r18; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 58, CPyStatic_main___globals, "faster_hexbytes.main.HexBytes", cpy_r_r18); - goto CPyL11; - } - return cpy_r_r19; -CPyL9: ; - if (likely(PyLong_Check(cpy_r_r12))) - cpy_r_r20 = CPyTagged_FromObject(cpy_r_r12); - else { - CPy_TypeError("int", cpy_r_r12); cpy_r_r20 = CPY_INT_TAG; - } - CPy_DECREF(cpy_r_r12); - if (unlikely(cpy_r_r20 == CPY_INT_TAG)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 60, CPyStatic_main___globals); - goto CPyL11; - } - cpy_r_r21 = CPyTagged_StealAsObject(cpy_r_r20); - return cpy_r_r21; -CPyL11: ; - cpy_r_r22 = NULL; - return cpy_r_r22; -CPyL12: ; - CPy_DecRef(cpy_r_r12); - goto CPyL11; -} - -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(Py_TYPE(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__", 53, 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_r2; - PyObject *cpy_r_r3; - PyObject *cpy_r_r4; - 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_r13; - PyObject *cpy_r_r14; - PyObject *cpy_r_r15; - PyObject *cpy_r_r16; - PyObject *cpy_r_r17; - CPyPtr cpy_r_r18; - CPyPtr cpy_r_r19; - CPyPtr cpy_r_r20; - CPyPtr cpy_r_r21; - PyObject *cpy_r_r22; - PyObject *cpy_r_r23; - cpy_r_r0 = CPyStatics[17]; /* '' */ - cpy_r_r1 = CPyStatics[39]; /* 'HexBytes(' */ - cpy_r_r2 = CPyStatics[19]; /* '{!r:{}}' */ - cpy_r_r3 = CPyStatics[24]; /* '0x' */ - cpy_r_r4 = CPyStatics[15]; /* 'hex' */ - PyObject *cpy_r_r5[1] = {cpy_r_self}; - cpy_r_r6 = (PyObject **)&cpy_r_r5; - cpy_r_r7 = PyObject_VectorcallMethod(cpy_r_r4, cpy_r_r6, 9223372036854775809ULL, 0); - if (unlikely(cpy_r_r7 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); - goto CPyL8; - } - if (likely(PyUnicode_Check(cpy_r_r7))) - cpy_r_r8 = cpy_r_r7; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals, "str", cpy_r_r7); - goto CPyL8; - } - cpy_r_r9 = PyUnicode_Concat(cpy_r_r3, cpy_r_r8); - CPy_DECREF(cpy_r_r8); - if (unlikely(cpy_r_r9 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); - goto CPyL8; - } - cpy_r_r10 = CPyStatics[17]; /* '' */ - cpy_r_r11 = CPyStatics[20]; /* 'format' */ - PyObject *cpy_r_r12[3] = {cpy_r_r2, cpy_r_r9, cpy_r_r10}; - cpy_r_r13 = (PyObject **)&cpy_r_r12; - cpy_r_r14 = PyObject_VectorcallMethod(cpy_r_r11, cpy_r_r13, 9223372036854775811ULL, 0); - if (unlikely(cpy_r_r14 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); - goto CPyL9; - } - CPy_DECREF(cpy_r_r9); - if (likely(PyUnicode_Check(cpy_r_r14))) - cpy_r_r15 = cpy_r_r14; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals, "str", cpy_r_r14); - goto CPyL8; - } - cpy_r_r16 = CPyStatics[40]; /* ')' */ - cpy_r_r17 = PyList_New(3); - if (unlikely(cpy_r_r17 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); - goto CPyL10; - } - cpy_r_r18 = (CPyPtr)&((PyListObject *)cpy_r_r17)->ob_item; - cpy_r_r19 = *(CPyPtr *)cpy_r_r18; - CPy_INCREF(cpy_r_r1); - *(PyObject * *)cpy_r_r19 = cpy_r_r1; - cpy_r_r20 = cpy_r_r19 + 8; - *(PyObject * *)cpy_r_r20 = cpy_r_r15; - CPy_INCREF(cpy_r_r16); - cpy_r_r21 = cpy_r_r19 + 16; - *(PyObject * *)cpy_r_r21 = cpy_r_r16; - cpy_r_r22 = PyUnicode_Join(cpy_r_r0, cpy_r_r17); - CPy_DECREF_NO_IMM(cpy_r_r17); - if (unlikely(cpy_r_r22 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 63, CPyStatic_main___globals); - goto CPyL8; - } - return cpy_r_r22; -CPyL8: ; - cpy_r_r23 = NULL; - return cpy_r_r23; -CPyL9: ; - CPy_DecRef(cpy_r_r9); - goto CPyL8; -CPyL10: ; - CPy_DecRef(cpy_r_r15); - goto CPyL8; -} - -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(Py_TYPE(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__", 62, 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[24]; /* '0x' */ - cpy_r_r1 = CPyStatics[15]; /* '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", 69, 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", 69, CPyStatic_main___globals, "str", cpy_r_r4); - goto CPyL4; - } - cpy_r_r6 = PyUnicode_Concat(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", 69, 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(Py_TYPE(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", 65, 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; - PyObject *cpy_r_r1; - PyObject *cpy_r_r2; - PyObject *cpy_r_r3; - PyObject *cpy_r_r4; - PyObject **cpy_r_r6; - PyObject *cpy_r_r7; - PyObject *cpy_r_r8; - tuple_T2OO cpy_r_r9; - tuple_T2OT2OO cpy_r_r10; - tuple_T2OT2OO cpy_r_r11; - cpy_r_r0 = (PyObject *)&PyBytes_Type; - cpy_r_r1 = CPyStatics[36]; /* '__new__' */ - cpy_r_r2 = CPyObject_GetAttr(cpy_r_r0, cpy_r_r1); - if (unlikely(cpy_r_r2 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", 79, CPyStatic_main___globals); - goto CPyL4; - } - cpy_r_r3 = CPy_TYPE(cpy_r_self); - cpy_r_r4 = (PyObject *)&PyBytes_Type; - PyObject *cpy_r_r5[1] = {cpy_r_self}; - cpy_r_r6 = (PyObject **)&cpy_r_r5; - cpy_r_r7 = PyObject_Vectorcall(cpy_r_r4, cpy_r_r6, 1, 0); - if (unlikely(cpy_r_r7 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", 79, CPyStatic_main___globals); - goto CPyL5; - } - if (likely(PyBytes_Check(cpy_r_r7) || PyByteArray_Check(cpy_r_r7))) - cpy_r_r8 = cpy_r_r7; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__reduce__", 79, CPyStatic_main___globals, "bytes", cpy_r_r7); - goto CPyL5; - } - cpy_r_r9.f0 = cpy_r_r3; - cpy_r_r9.f1 = cpy_r_r8; - cpy_r_r10.f0 = cpy_r_r2; - cpy_r_r10.f1 = cpy_r_r9; - return cpy_r_r10; -CPyL4: ; - tuple_T2OT2OO __tmp6 = { NULL, (tuple_T2OO) { NULL, NULL } }; - cpy_r_r11 = __tmp6; - return cpy_r_r11; -CPyL5: ; - CPy_DecRef(cpy_r_r2); - CPy_DecRef(cpy_r_r3); - goto CPyL4; -} - -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(Py_TYPE(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__", 71, 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; - PyObject *cpy_r_r10; - PyObject *cpy_r_r11; - PyObject *cpy_r_r12; - PyObject *cpy_r_r13; - PyObject *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; - 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; - tuple_T6OOOOOO cpy_r_r34; - PyObject *cpy_r_r35; - PyObject *cpy_r_r36; - PyObject *cpy_r_r37; - PyObject *cpy_r_r38; - int32_t cpy_r_r39; - char cpy_r_r40; - PyObject *cpy_r_r41; - PyObject *cpy_r_r42; - PyObject *cpy_r_r43; - PyObject *cpy_r_r44; - PyObject *cpy_r_r45; - PyObject *cpy_r_r46; - PyObject *cpy_r_r47; - char cpy_r_r48; - PyObject *cpy_r_r49; - PyObject *cpy_r_r50; - PyObject *cpy_r_r51; - PyObject **cpy_r_r53; - 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_r62; - PyObject **cpy_r_r64; - PyObject *cpy_r_r65; - PyObject *cpy_r_r66; - int32_t cpy_r_r67; - char cpy_r_r68; - PyObject *cpy_r_r69; - PyObject *cpy_r_r70; - int32_t cpy_r_r71; - char cpy_r_r72; - PyObject *cpy_r_r73; - PyObject *cpy_r_r74; - int32_t cpy_r_r75; - char cpy_r_r76; - PyObject *cpy_r_r77; - PyObject *cpy_r_r78; - int32_t cpy_r_r79; - char cpy_r_r80; - PyObject *cpy_r_r81; - PyObject *cpy_r_r82; - int32_t cpy_r_r83; - char cpy_r_r84; - PyObject *cpy_r_r85; - PyObject *cpy_r_r86; - int32_t cpy_r_r87; - char cpy_r_r88; - PyObject *cpy_r_r89; - PyObject *cpy_r_r90; - int32_t cpy_r_r91; - char cpy_r_r92; - PyObject *cpy_r_r93; - PyObject *cpy_r_r94; - int32_t cpy_r_r95; - char cpy_r_r96; - PyObject **cpy_r_r98; - PyObject *cpy_r_r99; - PyObject *cpy_r_r100; - PyObject *cpy_r_r101; - PyObject *cpy_r_r102; - PyObject *cpy_r_r103; - PyObject **cpy_r_r105; - PyObject *cpy_r_r106; - PyObject *cpy_r_r107; - PyObject **cpy_r_r109; - PyObject *cpy_r_r110; - PyObject *cpy_r_r111; - PyObject *cpy_r_r112; - int32_t cpy_r_r113; - char cpy_r_r114; - PyObject *cpy_r_r115; - char cpy_r_r116; - 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[3]; /* '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 CPyL45; - } - CPyModule_builtins = cpy_r_r4; - CPy_INCREF(CPyModule_builtins); - CPy_DECREF(cpy_r_r4); -CPyL3: ; - cpy_r_r5 = CPyStatics[73]; /* ('TYPE_CHECKING', 'Callable', 'Tuple', 'Type', 'Union', - 'overload') */ - cpy_r_r6 = CPyStatics[35]; /* '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", "", 1, CPyStatic_main___globals); - goto CPyL45; - } - CPyModule_typing = cpy_r_r8; - CPy_INCREF(CPyModule_typing); - CPy_DECREF(cpy_r_r8); - cpy_r_r9 = CPyStatics[74]; /* ('mypyc_attr',) */ - cpy_r_r10 = CPyStatics[47]; /* 'mypy_extensions' */ - cpy_r_r11 = CPyStatic_main___globals; - cpy_r_r12 = CPyImport_ImportFromMany(cpy_r_r10, cpy_r_r9, cpy_r_r9, cpy_r_r11); - if (unlikely(cpy_r_r12 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 10, CPyStatic_main___globals); - goto CPyL45; - } - CPyModule_mypy_extensions = cpy_r_r12; - CPy_INCREF(CPyModule_mypy_extensions); - CPy_DECREF(cpy_r_r12); - cpy_r_r13 = CPyStatics[75]; /* ('Self',) */ - cpy_r_r14 = CPyStatics[49]; /* 'typing_extensions' */ - cpy_r_r15 = CPyStatic_main___globals; - cpy_r_r16 = CPyImport_ImportFromMany(cpy_r_r14, cpy_r_r13, cpy_r_r13, cpy_r_r15); - if (unlikely(cpy_r_r16 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 13, CPyStatic_main___globals); - goto CPyL45; - } - CPyModule_typing_extensions = cpy_r_r16; - CPy_INCREF(CPyModule_typing_extensions); - CPy_DECREF(cpy_r_r16); - cpy_r_r17 = CPyStatics[76]; /* ('to_bytes',) */ - cpy_r_r18 = CPyStatics[51]; /* 'faster_hexbytes._utils' */ - cpy_r_r19 = CPyStatic_main___globals; - cpy_r_r20 = CPyImport_ImportFromMany(cpy_r_r18, cpy_r_r17, cpy_r_r17, cpy_r_r19); - if (unlikely(cpy_r_r20 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 17, CPyStatic_main___globals); - goto CPyL45; - } - CPyModule_faster_hexbytes____utils = cpy_r_r20; - CPy_INCREF(CPyModule_faster_hexbytes____utils); - CPy_DECREF(cpy_r_r20); - cpy_r_r21 = CPyStatic_main___globals; - cpy_r_r22 = CPyStatics[34]; /* 'Union' */ - cpy_r_r23 = CPyDict_GetItem(cpy_r_r21, cpy_r_r22); - if (unlikely(cpy_r_r23 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); - goto CPyL45; - } - cpy_r_r24 = (PyObject *)&PyBool_Type; - cpy_r_r25 = CPyModule_builtins; - cpy_r_r26 = CPyStatics[52]; /* 'bytearray' */ - cpy_r_r27 = CPyObject_GetAttr(cpy_r_r25, cpy_r_r26); - if (unlikely(cpy_r_r27 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); - goto CPyL46; - } - cpy_r_r28 = (PyObject *)&PyBytes_Type; - cpy_r_r29 = (PyObject *)&PyLong_Type; - cpy_r_r30 = (PyObject *)&PyUnicode_Type; - cpy_r_r31 = CPyModule_builtins; - cpy_r_r32 = CPyStatics[16]; /* 'memoryview' */ - cpy_r_r33 = CPyObject_GetAttr(cpy_r_r31, cpy_r_r32); - if (unlikely(cpy_r_r33 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); - goto CPyL47; - } - CPy_INCREF(cpy_r_r24); - CPy_INCREF(cpy_r_r28); - CPy_INCREF(cpy_r_r29); - CPy_INCREF(cpy_r_r30); - cpy_r_r34.f0 = cpy_r_r24; - cpy_r_r34.f1 = cpy_r_r27; - cpy_r_r34.f2 = cpy_r_r28; - cpy_r_r34.f3 = cpy_r_r29; - cpy_r_r34.f4 = cpy_r_r30; - cpy_r_r34.f5 = cpy_r_r33; - cpy_r_r35 = PyTuple_New(6); - if (unlikely(cpy_r_r35 == NULL)) - CPyError_OutOfMemory(); - PyObject *__tmp11 = cpy_r_r34.f0; - PyTuple_SET_ITEM(cpy_r_r35, 0, __tmp11); - PyObject *__tmp12 = cpy_r_r34.f1; - PyTuple_SET_ITEM(cpy_r_r35, 1, __tmp12); - PyObject *__tmp13 = cpy_r_r34.f2; - PyTuple_SET_ITEM(cpy_r_r35, 2, __tmp13); - PyObject *__tmp14 = cpy_r_r34.f3; - PyTuple_SET_ITEM(cpy_r_r35, 3, __tmp14); - PyObject *__tmp15 = cpy_r_r34.f4; - PyTuple_SET_ITEM(cpy_r_r35, 4, __tmp15); - PyObject *__tmp16 = cpy_r_r34.f5; - PyTuple_SET_ITEM(cpy_r_r35, 5, __tmp16); - cpy_r_r36 = PyObject_GetItem(cpy_r_r23, cpy_r_r35); - CPy_DECREF(cpy_r_r23); - CPy_DECREF(cpy_r_r35); - if (unlikely(cpy_r_r36 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); - goto CPyL45; - } - cpy_r_r37 = CPyStatic_main___globals; - cpy_r_r38 = CPyStatics[53]; /* 'BytesLike' */ - cpy_r_r39 = CPyDict_SetItem(cpy_r_r37, cpy_r_r38, cpy_r_r36); - CPy_DECREF(cpy_r_r36); - cpy_r_r40 = cpy_r_r39 >= 0; - if (unlikely(!cpy_r_r40)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 26, CPyStatic_main___globals); - goto CPyL45; - } - cpy_r_r41 = CPyModule_builtins; - cpy_r_r42 = CPyStatics[54]; /* 'bytes' */ - cpy_r_r43 = CPyObject_GetAttr(cpy_r_r41, cpy_r_r42); - if (unlikely(cpy_r_r43 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL45; - } - cpy_r_r44 = PyTuple_Pack(1, cpy_r_r43); - CPy_DECREF(cpy_r_r43); - if (unlikely(cpy_r_r44 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL45; - } - cpy_r_r45 = (PyObject *)&PyType_Type; - cpy_r_r46 = CPy_CalculateMetaclass(cpy_r_r45, cpy_r_r44); - if (unlikely(cpy_r_r46 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL48; - } - cpy_r_r47 = CPyStatics[55]; /* '__prepare__' */ - cpy_r_r48 = PyObject_HasAttr(cpy_r_r46, cpy_r_r47); - if (!cpy_r_r48) goto CPyL21; - cpy_r_r49 = CPyStatics[7]; /* 'HexBytes' */ - cpy_r_r50 = CPyStatics[55]; /* '__prepare__' */ - cpy_r_r51 = CPyObject_GetAttr(cpy_r_r46, cpy_r_r50); - if (unlikely(cpy_r_r51 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL48; - } - PyObject *cpy_r_r52[2] = {cpy_r_r49, cpy_r_r44}; - cpy_r_r53 = (PyObject **)&cpy_r_r52; - cpy_r_r54 = PyObject_Vectorcall(cpy_r_r51, cpy_r_r53, 2, 0); - CPy_DECREF(cpy_r_r51); - if (unlikely(cpy_r_r54 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL48; - } - if (likely(PyDict_Check(cpy_r_r54))) - cpy_r_r55 = cpy_r_r54; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals, "dict", cpy_r_r54); - goto CPyL48; - } - cpy_r_r56 = cpy_r_r55; - goto CPyL23; -CPyL21: ; - cpy_r_r57 = PyDict_New(); - if (unlikely(cpy_r_r57 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL48; - } - cpy_r_r56 = cpy_r_r57; -CPyL23: ; - cpy_r_r58 = PyDict_New(); - if (unlikely(cpy_r_r58 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL49; - } - cpy_r_r59 = CPyDef_main_____new___3_HexBytes_obj(); - if (unlikely(cpy_r_r59 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 41, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r60 = CPyModule_builtins; - cpy_r_r61 = CPyStatics[56]; /* 'staticmethod' */ - cpy_r_r62 = CPyObject_GetAttr(cpy_r_r60, cpy_r_r61); - if (unlikely(cpy_r_r62 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 41, CPyStatic_main___globals); - goto CPyL51; - } - PyObject *cpy_r_r63[1] = {cpy_r_r59}; - cpy_r_r64 = (PyObject **)&cpy_r_r63; - cpy_r_r65 = PyObject_Vectorcall(cpy_r_r62, cpy_r_r64, 1, 0); - CPy_DECREF(cpy_r_r62); - if (unlikely(cpy_r_r65 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 41, CPyStatic_main___globals); - goto CPyL51; - } - CPy_DECREF_NO_IMM(cpy_r_r59); - cpy_r_r66 = CPyStatics[36]; /* '__new__' */ - cpy_r_r67 = CPyDict_SetItem(cpy_r_r56, cpy_r_r66, cpy_r_r65); - CPy_DECREF(cpy_r_r65); - cpy_r_r68 = cpy_r_r67 >= 0; - if (unlikely(!cpy_r_r68)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 41, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r69 = CPyDef_main_____getitem___3_HexBytes_obj(); - if (unlikely(cpy_r_r69 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 53, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r70 = CPyStatics[38]; /* '__getitem__' */ - cpy_r_r71 = CPyDict_SetItem(cpy_r_r56, cpy_r_r70, cpy_r_r69); - CPy_DECREF_NO_IMM(cpy_r_r69); - cpy_r_r72 = cpy_r_r71 >= 0; - if (unlikely(!cpy_r_r72)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 53, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r73 = CPyDef_main_____repr___3_HexBytes_obj(); - if (unlikely(cpy_r_r73 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 62, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r74 = CPyStatics[57]; /* '__repr__' */ - cpy_r_r75 = CPyDict_SetItem(cpy_r_r56, cpy_r_r74, cpy_r_r73); - CPy_DECREF_NO_IMM(cpy_r_r73); - cpy_r_r76 = cpy_r_r75 >= 0; - if (unlikely(!cpy_r_r76)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 62, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r77 = CPyDef_main___to_0x_hex_HexBytes_obj(); - if (unlikely(cpy_r_r77 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 65, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r78 = CPyStatics[58]; /* 'to_0x_hex' */ - cpy_r_r79 = CPyDict_SetItem(cpy_r_r56, cpy_r_r78, cpy_r_r77); - CPy_DECREF_NO_IMM(cpy_r_r77); - cpy_r_r80 = cpy_r_r79 >= 0; - if (unlikely(!cpy_r_r80)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 65, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r81 = CPyDef_main_____reduce___3_HexBytes_obj(); - if (unlikely(cpy_r_r81 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 71, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r82 = CPyStatics[59]; /* '__reduce__' */ - cpy_r_r83 = CPyDict_SetItem(cpy_r_r56, cpy_r_r82, cpy_r_r81); - CPy_DECREF_NO_IMM(cpy_r_r81); - cpy_r_r84 = cpy_r_r83 >= 0; - if (unlikely(!cpy_r_r84)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 71, CPyStatic_main___globals); - goto CPyL50; - } - cpy_r_r85 = CPyStatics[7]; /* 'HexBytes' */ - cpy_r_r86 = CPyStatics[60]; /* '__annotations__' */ - cpy_r_r87 = CPyDict_SetItem(cpy_r_r56, cpy_r_r86, cpy_r_r58); - CPy_DECREF(cpy_r_r58); - cpy_r_r88 = cpy_r_r87 >= 0; - if (unlikely(!cpy_r_r88)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL49; - } - cpy_r_r89 = CPyStatics[61]; /* 'mypyc filler docstring' */ - cpy_r_r90 = CPyStatics[62]; /* '__doc__' */ - cpy_r_r91 = CPyDict_SetItem(cpy_r_r56, cpy_r_r90, cpy_r_r89); - cpy_r_r92 = cpy_r_r91 >= 0; - if (unlikely(!cpy_r_r92)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL49; - } - cpy_r_r93 = CPyStatics[8]; /* 'faster_hexbytes.main' */ - cpy_r_r94 = CPyStatics[63]; /* '__module__' */ - cpy_r_r95 = CPyDict_SetItem(cpy_r_r56, cpy_r_r94, cpy_r_r93); - cpy_r_r96 = cpy_r_r95 >= 0; - if (unlikely(!cpy_r_r96)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL49; - } - PyObject *cpy_r_r97[3] = {cpy_r_r85, cpy_r_r44, cpy_r_r56}; - cpy_r_r98 = (PyObject **)&cpy_r_r97; - cpy_r_r99 = PyObject_Vectorcall(cpy_r_r46, cpy_r_r98, 3, 0); - if (unlikely(cpy_r_r99 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL49; - } - CPy_DECREF(cpy_r_r56); - CPy_DECREF(cpy_r_r44); - cpy_r_r100 = CPyStatic_main___globals; - cpy_r_r101 = CPyStatics[46]; /* 'mypyc_attr' */ - cpy_r_r102 = CPyDict_GetItem(cpy_r_r100, cpy_r_r101); - if (unlikely(cpy_r_r102 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 29, CPyStatic_main___globals); - goto CPyL52; - } - cpy_r_r103 = 0 ? Py_True : Py_False; - PyObject *cpy_r_r104[1] = {cpy_r_r103}; - cpy_r_r105 = (PyObject **)&cpy_r_r104; - cpy_r_r106 = CPyStatics[77]; /* ('native_class',) */ - cpy_r_r107 = PyObject_Vectorcall(cpy_r_r102, cpy_r_r105, 0, cpy_r_r106); - CPy_DECREF(cpy_r_r102); - if (unlikely(cpy_r_r107 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 29, CPyStatic_main___globals); - goto CPyL52; - } - PyObject *cpy_r_r108[1] = {cpy_r_r99}; - cpy_r_r109 = (PyObject **)&cpy_r_r108; - cpy_r_r110 = PyObject_Vectorcall(cpy_r_r107, cpy_r_r109, 1, 0); - CPy_DECREF(cpy_r_r107); - if (unlikely(cpy_r_r110 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL52; - } - CPy_DECREF(cpy_r_r99); - CPyType_main___HexBytes = (PyTypeObject *)cpy_r_r110; - CPy_INCREF(CPyType_main___HexBytes); - cpy_r_r111 = CPyStatic_main___globals; - cpy_r_r112 = CPyStatics[7]; /* 'HexBytes' */ - cpy_r_r113 = PyDict_SetItem(cpy_r_r111, cpy_r_r112, cpy_r_r110); - CPy_DECREF(cpy_r_r110); - cpy_r_r114 = cpy_r_r113 >= 0; - if (unlikely(!cpy_r_r114)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 30, CPyStatic_main___globals); - goto CPyL45; - } - cpy_r_r115 = (PyObject *)CPyType_main___HexBytes; - return 1; -CPyL45: ; - cpy_r_r116 = 2; - return cpy_r_r116; -CPyL46: ; - CPy_DecRef(cpy_r_r23); - goto CPyL45; -CPyL47: ; - CPy_DecRef(cpy_r_r23); - CPy_DecRef(cpy_r_r27); - goto CPyL45; -CPyL48: ; - CPy_DecRef(cpy_r_r44); - goto CPyL45; -CPyL49: ; - CPy_DecRef(cpy_r_r44); - CPy_DecRef(cpy_r_r56); - goto CPyL45; -CPyL50: ; - CPy_DecRef(cpy_r_r44); - CPy_DecRef(cpy_r_r56); - CPy_DecRef(cpy_r_r58); - goto CPyL45; -CPyL51: ; - CPy_DecRef(cpy_r_r44); - CPy_DecRef(cpy_r_r56); - CPy_DecRef(cpy_r_r58); - CPy_DecRef(cpy_r_r59); - goto CPyL45; -CPyL52: ; - CPy_DecRef(cpy_r_r99); - goto CPyL45; -} - -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_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[78]; -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 ", - "\003( may only contain [0-9a-fA-F] characters\tunhexlify\bbinascii", - "\006\031faster_hexbytes/_utils.py\b\005Union\006typing\a__new__\005super", - "\b\v__getitem__\tHexBytes(\001)\rTYPE_CHECKING\bCallable\005Tuple\004Type\boverload", - "\005\nmypyc_attr\017mypy_extensions\004Self\021typing_extensions\bto_bytes", - "\005\026faster_hexbytes._utils\tbytearray\tBytesLike\005bytes\v__prepare__", - "\005\fstaticmethod\b__repr__\tto_0x_hex\n__reduce__\017__annotations__", - "\004\026mypyc filler docstring\a__doc__\n__module__\fnative_class", - "", -}; -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[] = { - 11, 1, 4, 1, 5, 1, 7, 3, 31, 31, 31, 1, 70, 1, 34, 6, 41, 42, 43, - 44, 34, 45, 1, 46, 1, 48, 1, 50, 1, 64 -}; -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_mypy_extensions; -CPyModule *CPyModule_typing_extensions; -char CPyDef_faster_hexbytes_____top_level__(void); -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); -PyTypeObject *CPyType_main___HexBytes; -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 deleted file mode 100644 index d1ad01d..0000000 --- a/build/__native_6a32f4913d613d6a7ddf.h +++ /dev/null @@ -1,72 +0,0 @@ -#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 deleted file mode 100644 index 9277403..0000000 --- a/build/__native_internal_6a32f4913d613d6a7ddf.h +++ /dev/null @@ -1,75 +0,0 @@ -#ifndef MYPYC_NATIVE_INTERNAL_6a32f4913d613d6a7ddf_H -#define MYPYC_NATIVE_INTERNAL_6a32f4913d613d6a7ddf_H -#include -#include -#include "__native_6a32f4913d613d6a7ddf.h" - -int CPyGlobalsInit(void); - -extern PyObject *CPyStatics[78]; -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_mypy_extensions; -extern CPyModule *CPyModule_typing_extensions; -extern char CPyDef_faster_hexbytes_____top_level__(void); -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 PyTypeObject *CPyType_main___HexBytes; -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 deleted file mode 100644 index c09d246..0000000 --- a/build/faster_hexbytes.c +++ /dev/null @@ -1,21 +0,0 @@ -#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 deleted file mode 100644 index d9858f5..0000000 --- a/build/faster_hexbytes/_utils.c +++ /dev/null @@ -1,21 +0,0 @@ -#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 deleted file mode 100644 index 12ae3ec..0000000 --- a/build/faster_hexbytes/main.c +++ /dev/null @@ -1,21 +0,0 @@ -#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 deleted file mode 100644 index 88781dd..0000000 --- a/build/ops.txt +++ /dev/null @@ -1,1375 +0,0 @@ -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[bool, object, bytes, int, str] - r0 :: bytes - r1 :: object - r2 :: str - r3 :: object[3] - r4 :: object_ptr - r5 :: object - r6, r7 :: faster_hexbytes.main.HexBytes -L0: - r0 = to_bytes(val) - if is_error(r0) goto L4 (error at __new__:42) else goto L1 -L1: - r1 = load_address PyBytes_Type - r2 = '__new__' - r3 = [r1, cls, r0] - r4 = load_address r3 - r5 = PyObject_VectorcallMethod(r2, r4, 9223372036854775811, 0) - if is_error(r5) goto L5 (error at __new__:43) else goto L2 -L2: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L4 (error at __new__:43) else goto L3 -L3: - return r6 -L4: - r7 = :: faster_hexbytes.main.HexBytes - return r7 -L5: - dec_ref r0 - goto L4 - -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, r3 :: object - r4 :: object[2] - r5 :: object_ptr - r6 :: object - r7 :: str - r8 :: object - r9 :: object[1] - r10 :: object_ptr - r11 :: object - r12 :: union[int, bytes] - r13 :: str - r14 :: bool - r15 :: object - r16 :: object[1] - r17 :: object_ptr - r18 :: object - r19 :: faster_hexbytes.main.HexBytes - r20 :: int - r21 :: object - r22 :: union[int, bytes, faster_hexbytes.main.HexBytes] -L0: - r0 = builtins :: module - r1 = 'super' - r2 = CPyObject_GetAttr(r0, r1) - if is_error(r2) goto L11 (error at __getitem__:56) else goto L1 -L1: - r3 = faster_hexbytes.main.HexBytes :: type - r4 = [r3, self] - r5 = load_address r4 - r6 = PyObject_Vectorcall(r2, r5, 2, 0) - dec_ref r2 - if is_error(r6) goto L11 (error at __getitem__:56) else goto L2 -L2: - r7 = '__getitem__' - r8 = CPyObject_GetAttr(r6, r7) - dec_ref r6 - if is_error(r8) goto L11 (error at __getitem__:56) else goto L3 -L3: - r9 = [key] - r10 = load_address r9 - r11 = PyObject_Vectorcall(r8, r10, 1, 0) - dec_ref r8 - if is_error(r11) goto L11 (error at __getitem__:56) else goto L4 -L4: - r12 = cast(union[int, bytes], r11) - if is_error(r12) goto L11 (error at __getitem__:56) else goto L5 -L5: - r13 = 'hex' - r14 = PyObject_HasAttr(r12, r13) - if r14 goto L6 else goto L9 :: bool -L6: - r15 = CPy_TYPE(self) - r16 = [r12] - r17 = load_address r16 - r18 = PyObject_Vectorcall(r15, r17, 1, 0) - dec_ref r15 - if is_error(r18) goto L12 (error at __getitem__:58) else goto L7 -L7: - dec_ref r12 - r19 = cast(faster_hexbytes.main.HexBytes, r18) - if is_error(r19) goto L11 (error at __getitem__:58) else goto L8 -L8: - return r19 -L9: - r20 = unbox(int, r12) - dec_ref r12 - if is_error(r20) goto L11 (error at __getitem__:60) else goto L10 -L10: - r21 = box(int, r20) - return r21 -L11: - r22 = :: union[int, bytes, faster_hexbytes.main.HexBytes] - return r22 -L12: - dec_ref r12 - goto L11 - -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, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str -L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:63) else goto L1 -L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:63) else goto L2 -L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:63) else goto L3 -L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:63) else goto L4 -L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:63) else goto L5 -L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:63) else goto L6 -L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:63) else goto L7 -L7: - return r22 -L8: - r23 = :: str - return r23 -L9: - dec_ref r9 - goto L8 -L10: - dec_ref r15 - goto L8 - -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:69) else goto L1 -L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:69) else goto L2 -L2: - r6 = PyUnicode_Concat(r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:69) 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 :: str - r2, r3, r4 :: object - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8 :: bytes - r9 :: tuple[object, bytes] - r10, r11 :: tuple[object, tuple[object, bytes]] -L0: - r0 = load_address PyBytes_Type - r1 = '__new__' - r2 = CPyObject_GetAttr(r0, r1) - if is_error(r2) goto L4 (error at __reduce__:79) else goto L1 -L1: - r3 = CPy_TYPE(self) - r4 = load_address PyBytes_Type - r5 = [self] - r6 = load_address r5 - r7 = PyObject_Vectorcall(r4, r6, 1, 0) - if is_error(r7) goto L5 (error at __reduce__:79) else goto L2 -L2: - r8 = cast(bytes, r7) - if is_error(r8) goto L5 (error at __reduce__:79) else goto L3 -L3: - r9 = (r3, r8) - r10 = (r2, r9) - return r10 -L4: - r11 = :: tuple[object, tuple[object, bytes]] - return r11 -L5: - dec_ref r2 - dec_ref r3 - goto L4 - -def __top_level__(): - r0, r1 :: object - r2 :: bit - r3 :: str - r4, r5 :: object - r6 :: str - r7 :: dict - r8, r9 :: object - r10 :: str - r11 :: dict - r12, r13 :: object - r14 :: str - r15 :: dict - r16, r17 :: object - r18 :: str - r19 :: dict - r20 :: object - r21 :: dict - r22 :: str - r23, r24, r25 :: object - r26 :: str - r27, r28, r29, r30, r31 :: object - r32 :: str - r33 :: object - r34 :: tuple[object, object, object, object, object, object] - r35, r36 :: object - r37 :: dict - r38 :: str - r39 :: i32 - r40 :: bit - r41 :: object - r42 :: str - r43 :: object - r44 :: tuple - r45, r46 :: object - r47 :: str - r48 :: bool - r49, r50 :: str - r51 :: object - r52 :: object[2] - r53 :: object_ptr - r54 :: object - r55, r56, r57, r58 :: dict - r59 :: faster_hexbytes.main.__new___HexBytes_obj - r60 :: object - r61 :: str - r62 :: object - r63 :: object[1] - r64 :: object_ptr - r65 :: object - r66 :: str - r67 :: i32 - r68 :: bit - r69 :: faster_hexbytes.main.__getitem___HexBytes_obj - r70 :: str - r71 :: i32 - r72 :: bit - r73 :: faster_hexbytes.main.__repr___HexBytes_obj - r74 :: str - r75 :: i32 - r76 :: bit - r77 :: faster_hexbytes.main.to_0x_hex_HexBytes_obj - r78 :: str - r79 :: i32 - r80 :: bit - r81 :: faster_hexbytes.main.__reduce___HexBytes_obj - r82 :: str - r83 :: i32 - r84 :: bit - r85, r86 :: str - r87 :: i32 - r88 :: bit - r89, r90 :: str - r91 :: i32 - r92 :: bit - r93, r94 :: str - r95 :: i32 - r96 :: bit - r97 :: object[3] - r98 :: object_ptr - r99 :: object - r100 :: dict - r101 :: str - r102, r103 :: object - r104 :: object[1] - r105 :: object_ptr - r106, r107 :: object - r108 :: object[1] - r109 :: object_ptr - r110 :: object - r111 :: dict - r112 :: str - r113 :: i32 - r114 :: bit - r115 :: object - r116 :: 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 L45 (error at :-1) else goto L2 -L2: - builtins = r4 :: module - dec_ref r4 -L3: - r5 = ('TYPE_CHECKING', 'Callable', 'Tuple', 'Type', 'Union', 'overload') - r6 = 'typing' - r7 = faster_hexbytes.main.globals :: static - r8 = CPyImport_ImportFromMany(r6, r5, r5, r7) - if is_error(r8) goto L45 (error at :1) else goto L4 -L4: - typing = r8 :: module - dec_ref r8 - r9 = ('mypyc_attr',) - r10 = 'mypy_extensions' - r11 = faster_hexbytes.main.globals :: static - r12 = CPyImport_ImportFromMany(r10, r9, r9, r11) - if is_error(r12) goto L45 (error at :10) else goto L5 -L5: - mypy_extensions = r12 :: module - dec_ref r12 - r13 = ('Self',) - r14 = 'typing_extensions' - r15 = faster_hexbytes.main.globals :: static - r16 = CPyImport_ImportFromMany(r14, r13, r13, r15) - if is_error(r16) goto L45 (error at :13) else goto L6 -L6: - typing_extensions = r16 :: module - dec_ref r16 - r17 = ('to_bytes',) - r18 = 'faster_hexbytes._utils' - r19 = faster_hexbytes.main.globals :: static - r20 = CPyImport_ImportFromMany(r18, r17, r17, r19) - if is_error(r20) goto L45 (error at :17) else goto L7 -L7: - faster_hexbytes._utils = r20 :: module - dec_ref r20 - if 0 goto L8 else goto L8 :: bool -L8: - r21 = faster_hexbytes.main.globals :: static - r22 = 'Union' - r23 = CPyDict_GetItem(r21, r22) - if is_error(r23) goto L45 (error at :26) else goto L9 -L9: - r24 = load_address PyBool_Type - r25 = builtins :: module - r26 = 'bytearray' - r27 = CPyObject_GetAttr(r25, r26) - if is_error(r27) goto L46 (error at :26) else goto L10 -L10: - r28 = load_address PyBytes_Type - r29 = load_address PyLong_Type - r30 = load_address PyUnicode_Type - r31 = builtins :: module - r32 = 'memoryview' - r33 = CPyObject_GetAttr(r31, r32) - if is_error(r33) goto L47 (error at :26) else goto L11 -L11: - inc_ref r24 - inc_ref r28 - inc_ref r29 - inc_ref r30 - r34 = (r24, r27, r28, r29, r30, r33) - r35 = box(tuple[object, object, object, object, object, object], r34) - r36 = PyObject_GetItem(r23, r35) - dec_ref r23 - dec_ref r35 - if is_error(r36) goto L45 (error at :26) else goto L12 -L12: - r37 = faster_hexbytes.main.globals :: static - r38 = 'BytesLike' - r39 = CPyDict_SetItem(r37, r38, r36) - dec_ref r36 - r40 = r39 >= 0 :: signed - if not r40 goto L45 (error at :26) else goto L13 :: bool -L13: - r41 = builtins :: module - r42 = 'bytes' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L45 (error at :30) else goto L14 -L14: - r44 = PyTuple_Pack(1, r43) - dec_ref r43 - if is_error(r44) goto L45 (error at :30) else goto L15 -L15: - r45 = load_address PyType_Type - r46 = CPy_CalculateMetaclass(r45, r44) - if is_error(r46) goto L48 (error at :30) else goto L16 -L16: - r47 = '__prepare__' - r48 = PyObject_HasAttr(r46, r47) - if r48 goto L17 else goto L21 :: bool -L17: - r49 = 'HexBytes' - r50 = '__prepare__' - r51 = CPyObject_GetAttr(r46, r50) - if is_error(r51) goto L48 (error at :30) else goto L18 -L18: - r52 = [r49, r44] - r53 = load_address r52 - r54 = PyObject_Vectorcall(r51, r53, 2, 0) - dec_ref r51 - if is_error(r54) goto L48 (error at :30) else goto L19 -L19: - r55 = cast(dict, r54) - if is_error(r55) goto L48 (error at :30) else goto L20 -L20: - r56 = r55 - goto L23 -L21: - r57 = PyDict_New() - if is_error(r57) goto L48 (error at :30) else goto L22 -L22: - r56 = r57 -L23: - r58 = PyDict_New() - if is_error(r58) goto L49 (error at :30) else goto L24 -L24: - r59 = __new___HexBytes_obj() - if is_error(r59) goto L50 (error at :41) else goto L25 -L25: - r60 = builtins :: module - r61 = 'staticmethod' - r62 = CPyObject_GetAttr(r60, r61) - if is_error(r62) goto L51 (error at :41) else goto L26 -L26: - r63 = [r59] - r64 = load_address r63 - r65 = PyObject_Vectorcall(r62, r64, 1, 0) - dec_ref r62 - if is_error(r65) goto L51 (error at :41) else goto L27 -L27: - dec_ref r59 - r66 = '__new__' - r67 = CPyDict_SetItem(r56, r66, r65) - dec_ref r65 - r68 = r67 >= 0 :: signed - if not r68 goto L50 (error at :41) else goto L28 :: bool -L28: - r69 = __getitem___HexBytes_obj() - if is_error(r69) goto L50 (error at :53) else goto L29 -L29: - r70 = '__getitem__' - r71 = CPyDict_SetItem(r56, r70, r69) - dec_ref r69 - r72 = r71 >= 0 :: signed - if not r72 goto L50 (error at :53) else goto L30 :: bool -L30: - r73 = __repr___HexBytes_obj() - if is_error(r73) goto L50 (error at :62) else goto L31 -L31: - r74 = '__repr__' - r75 = CPyDict_SetItem(r56, r74, r73) - dec_ref r73 - r76 = r75 >= 0 :: signed - if not r76 goto L50 (error at :62) else goto L32 :: bool -L32: - r77 = to_0x_hex_HexBytes_obj() - if is_error(r77) goto L50 (error at :65) else goto L33 -L33: - r78 = 'to_0x_hex' - r79 = CPyDict_SetItem(r56, r78, r77) - dec_ref r77 - r80 = r79 >= 0 :: signed - if not r80 goto L50 (error at :65) else goto L34 :: bool -L34: - r81 = __reduce___HexBytes_obj() - if is_error(r81) goto L50 (error at :71) else goto L35 -L35: - r82 = '__reduce__' - r83 = CPyDict_SetItem(r56, r82, r81) - dec_ref r81 - r84 = r83 >= 0 :: signed - if not r84 goto L50 (error at :71) else goto L36 :: bool -L36: - r85 = 'HexBytes' - r86 = '__annotations__' - r87 = CPyDict_SetItem(r56, r86, r58) - dec_ref r58 - r88 = r87 >= 0 :: signed - if not r88 goto L49 (error at :30) else goto L37 :: bool -L37: - r89 = 'mypyc filler docstring' - r90 = '__doc__' - r91 = CPyDict_SetItem(r56, r90, r89) - r92 = r91 >= 0 :: signed - if not r92 goto L49 (error at :30) else goto L38 :: bool -L38: - r93 = 'faster_hexbytes.main' - r94 = '__module__' - r95 = CPyDict_SetItem(r56, r94, r93) - r96 = r95 >= 0 :: signed - if not r96 goto L49 (error at :30) else goto L39 :: bool -L39: - r97 = [r85, r44, r56] - r98 = load_address r97 - r99 = PyObject_Vectorcall(r46, r98, 3, 0) - if is_error(r99) goto L49 (error at :30) else goto L40 -L40: - dec_ref r56 - dec_ref r44 - r100 = faster_hexbytes.main.globals :: static - r101 = 'mypyc_attr' - r102 = CPyDict_GetItem(r100, r101) - if is_error(r102) goto L52 (error at :29) else goto L41 -L41: - r103 = box(bool, 0) - r104 = [r103] - r105 = load_address r104 - r106 = ('native_class',) - r107 = PyObject_Vectorcall(r102, r105, 0, r106) - dec_ref r102 - if is_error(r107) goto L52 (error at :29) else goto L42 -L42: - r108 = [r99] - r109 = load_address r108 - r110 = PyObject_Vectorcall(r107, r109, 1, 0) - dec_ref r107 - if is_error(r110) goto L52 (error at :30) else goto L43 -L43: - dec_ref r99 - faster_hexbytes.main.HexBytes = r110 :: type - r111 = faster_hexbytes.main.globals :: static - r112 = 'HexBytes' - r113 = PyDict_SetItem(r111, r112, r110) - dec_ref r110 - r114 = r113 >= 0 :: signed - if not r114 goto L45 (error at :30) else goto L44 :: bool -L44: - r115 = faster_hexbytes.main.HexBytes :: type - return 1 -L45: - r116 = :: None - return r116 -L46: - dec_ref r23 - goto L45 -L47: - dec_ref r23 - dec_ref r27 - goto L45 -L48: - dec_ref r44 - goto L45 -L49: - dec_ref r44 - dec_ref r56 - goto L45 -L50: - dec_ref r44 - dec_ref r56 - dec_ref r58 - goto L45 -L51: - dec_ref r44 - dec_ref r56 - dec_ref r58 - dec_ref r59 - goto L45 -L52: - dec_ref r99 - goto L45 - -def to_bytes(val): - val :: union[bool, object, bytes, int, str] - 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:15) 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:17) else goto L5 -L5: - r4 = hexstr_to_bytes(r3) - dec_ref r3 - if is_error(r4) goto L51 (error at to_bytes:17) 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:19) else goto L9 -L9: - r10 = cast(bytes, r9) - if is_error(r10) goto L51 (error at to_bytes:19) 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:21) 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:25) 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:26) else goto L25 -L25: - r27 = CPyTagged_Str(r26) - dec_ref r26 :: int - if is_error(r27) goto L51 (error at to_bytes:26) 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:26) else goto L27 -L27: - r30 = builtins :: module - r31 = 'ValueError' - r32 = CPyObject_GetAttr(r30, r31) - if is_error(r32) goto L52 (error at to_bytes:26) 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:26) else goto L29 -L29: - dec_ref r29 - CPy_Raise(r35) - dec_ref r35 - if not 0 goto L51 (error at to_bytes:26) else goto L30 :: bool -L30: - unreachable -L31: - r36 = unbox(int, val) - if is_error(r36) goto L51 (error at to_bytes:28) else goto L32 -L32: - r37 = builtins :: module - r38 = 'hex' - r39 = CPyObject_GetAttr(r37, r38) - if is_error(r39) goto L53 (error at to_bytes:28) 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:28) else goto L34 -L34: - dec_ref r40 - r44 = cast(str, r43) - if is_error(r44) goto L51 (error at to_bytes:28) else goto L35 -L35: - r45 = to_bytes(r44) - dec_ref r44 - if is_error(r45) goto L51 (error at to_bytes:28) 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:29) 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:29) 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:30) else goto L41 -L41: - r56 = cast(bytes, r55) - if is_error(r56) goto L51 (error at to_bytes:30) 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:32) 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:32) else goto L45 -L45: - dec_ref r67 - r73 = ' to bytes' - r74 = PyList_New(5) - if is_error(r74) goto L56 (error at to_bytes:32) 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:32) else goto L47 -L47: - r82 = builtins :: module - r83 = 'TypeError' - r84 = CPyObject_GetAttr(r82, r83) - if is_error(r84) goto L57 (error at to_bytes:32) 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:32) else goto L49 -L49: - dec_ref r81 - CPy_Raise(r87) - dec_ref r87 - if not 0 goto L51 (error at to_bytes:32) 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 :: str - r32 :: object - r33 :: object[1] - r34 :: object_ptr - r35 :: object - r36, r37 :: 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 L29 (error at hexstr_to_bytes:36) else goto L1 -L1: - if r4 goto L2 else goto L5 :: bool -L2: - r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) - if is_error(r5) goto L29 (error at hexstr_to_bytes:37) else goto L3 -L3: - r6 = cast(str, r5) - if is_error(r6) goto L29 (error at hexstr_to_bytes:37) 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 L30 (error at hexstr_to_bytes:42) else goto L7 :: bool -L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L30 (error at hexstr_to_bytes:42) 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 L29 (error at hexstr_to_bytes:43) 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:48) else goto L31 -L13: - goto L25 -L14: - r15 = CPy_CatchError() - r16 = builtins :: module - r17 = 'UnicodeDecodeError' - r18 = CPyObject_GetAttr(r16, r17) - if is_error(r18) goto L32 (error at hexstr_to_bytes:49) else goto L15 -L15: - r19 = CPy_ExceptionMatches(r18) - dec_ref r18 - if r19 goto L16 else goto L33 :: 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:51) else goto L17 -L17: - r23 = builtins :: module - r24 = 'ValueError' - r25 = CPyObject_GetAttr(r23, r24) - if is_error(r25) goto L34 (error at hexstr_to_bytes:50) 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 L34 (error at hexstr_to_bytes:50) else goto L19 -L19: - dec_ref r22 - CPy_Raise(r28) - dec_ref r28 - if not 0 goto L23 (error at hexstr_to_bytes:50) else goto L35 :: bool -L20: - unreachable -L21: - CPy_Reraise() - if not 0 goto L23 else goto L36 :: bool -L22: - unreachable -L23: - CPy_RestoreExcInfo(r15) - dec_ref r15 - r29 = CPy_KeepPropagating() - if not r29 goto L29 else goto L24 :: bool -L24: - unreachable -L25: - r30 = binascii :: module - r31 = 'unhexlify' - r32 = CPyObject_GetAttr(r30, r31) - if is_error(r32) goto L37 (error at hexstr_to_bytes:54) else goto L26 -L26: - r33 = [r14] - r34 = load_address r33 - r35 = PyObject_Vectorcall(r32, r34, 1, 0) - dec_ref r32 - if is_error(r35) goto L37 (error at hexstr_to_bytes:54) else goto L27 -L27: - dec_ref r14 - r36 = cast(bytes, r35) - if is_error(r36) goto L29 (error at hexstr_to_bytes:54) else goto L28 -L28: - return r36 -L29: - r37 = :: bytes - return r37 -L30: - dec_ref non_prefixed_hex - goto L29 -L31: - dec_ref padded_hex - goto L13 -L32: - dec_ref padded_hex - goto L23 -L33: - dec_ref padded_hex - goto L21 -L34: - dec_ref r22 - goto L23 -L35: - dec_ref r15 - goto L20 -L36: - dec_ref r15 - goto L22 -L37: - dec_ref r14 - goto L29 - -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 :: object - r19 :: 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 L6 (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 L6 else goto L4 :: bool -L4: - r15 = ('Union',) - r16 = 'typing' - r17 = faster_hexbytes._utils.globals :: static - r18 = CPyImport_ImportFromMany(r16, r15, r15, r17) - if is_error(r18) goto L6 (error at :2) else goto L5 -L5: - typing = r18 :: module - dec_ref r18 - return 1 -L6: - r19 = :: None - return r19 - -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 diff --git a/build/temp.linux-x86_64-cpython-313/build/__native_6a32f4913d613d6a7ddf.o b/build/temp.linux-x86_64-cpython-313/build/__native_6a32f4913d613d6a7ddf.o deleted file mode 100644 index 1907731f39aa85a2d9082a8983b6ca9763541e53..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 342400 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 EAAG~M2LJ#7 diff --git a/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes.o b/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes.o deleted file mode 100644 index bd807a3eac9d395a8928f92ae5e1e99f74e5fddd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5296 zcmbtYU2Gdw7QWZxAx_;oX#+H+TjD@LQ1CcTLYhJguACCLu+$U+DSu{ck7I*9V~xku zUJxKcK~Yty+I?89v=2yh-`G`!Kw@83S$@-DSx@tvt9ERT z9et;}F2DE{D9tfv2l~4#zxd|x{STf$GcYm(JuH19d-}Gsj4hev`yYIxdLqAcF26Lh zJtiFi_x0=5sx~n4ERKbp!0~>G+>|~sUY*>PnW#+Rr|+y(s>Ncn*Xos7-K;yss@`@C zyI3>2rJiH7(FW*e%(PImZ@@@pJch<97Td7!)8Bo9So-zKrU+un=*2>wjtmPqIx&0^ z;{1|9tdRQMit#`9A;+WM-ktPXJ^?Oq}cwz166M!uAmWe_P#Vu6M`rVO%?xpI+`&4dY8Do(spI5gWjz-iC%BPXo z0T)tEM|Z3Jcc`%gQLen#omV%z8XreK_Y@9z3Lkc>Dt|!TV1So?K&>}tb0l1x<#`*Tq0?Vee# z*_LT_+Nq9tq;6JHj$UdQZD?#edil{*%eEY&>{vEBu}p9-8_Es6U8Cl@WkN%_>XTWa zw?FJ)7kURvkATPGtl{i+9Q!U9o4EkmIla~HGz`QGR^5bbz;F%rxA!-jmhI>b@>nd2 zqhCb1*@C8`Tm9CmfIXnanSHrK`)+0Fn$Q~T^n?amwlm$GnoQTta-&l*(k;<~4QzF44cj6ZcJV?SL&EfM}|jgsw2elC&wqXvB_&CjHf{456otG5+JDX zG%jN<2sZ68Hv+;ccDX| zvu@?B13fTlFHoOyHL4CueHxDx*%gvOecbomQocHXKP=@P0UYxN(xh8?@$-U|F%Kb; z|Ce16e$BW<_?uGB1#nuId;tGY%7MXz;q-ues;Pq0;HXd8itlPS| z0Ka3ThHWl1>TL%*xZt8uHw{vN4v9s$DCDx$Y#JsE(1b^r1{XFw!r)ORN4^}hxWDA1rhM7aK#*QtM6|Azq!>;Fz^_g855Q&6`JjX@0c z|0C_k{Kg@=CSYOXpO%T5>~Z{*bI>J?{~6%J`qyMY1phk_)cxZc_P0sL%bIevfqI3pc7_q$|ve)!pnt%?5O_78ukU5 z5b%8YiR`F84UNS6^_~bO6xkTmeIIa)OBpVni>IZ1(nDN^){kI(kD$+>{R`5*MvAfy z+J6Oj*#2d4vw&z{F#hn)Cwq#&u)fhQhLZw1B_|C3Z4qyepgpF^VD3V@*Q6rGr=NoB Sw-Fk{>|1jDl*h diff --git a/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/_utils.o b/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/_utils.o deleted file mode 100644 index 7ddfb93457e2ef5222e2e705b143a120055f2dea..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5296 zcmbtYU2Gf25#HtTBFdC0*-m0Qt|O{Q(!?;2qNK{QW5+ZoN3@Z~suMMG5|=%aN0AA6 zM;wnfS+q$JRRshifY3Yy1^O2EEiL@eqUcMZG%egd^d&(4fFN;!0CCb7ZqcWv0o<9r zozrPe1x-3IZ)U!onVsF8ojdvY6OTL`;hYh1_7L092xY95*pPEV%&|Qz$^JEb_h$=* z7mp(JSYi3o4fg%`gmNcn*Xos7-L8AZ zs@e7|w^*~frJiTCi$EQ(-e{xq7rGl??EWcu>x{=RijI$c_z2VQLW($xA#G;_F>UO2 zq0dB;LXS=+Z$q5lF@g+f&}WSQd;ldL4G!~CF!BLNF?@uH59+@LUHd2mY9tTdVm+j9 zvW$`?6Vj{Ny@HqdJ&YUd*d8r$cr5auekguq4`UID#2<|NfVPiickSRi2NuU7XU8rN zJTV5#h#D;LN{vA(`VM|?Vpm)n-8+i5BfA;9EgT8KT#~T?gNq48cpv1uV8#1*cGnrc zuzN9nHvU8$p~1}%tlmPGG%_p-LL8ZRh*bQC&e@=!8Q9*b?|4$@E{OI%Z*>>--M+>9kq-ldQ-Q&|-Kx%?*0);_Wl;OY zfEVR@OnbBYg3gNqx-{@AK=)}^yRi@T%&7=eFfY#cinEs4XgFmy_vk_@pFNn$P8yTO zcq-lWI<|Fm$+9iCUIx{4%eAB3nd$WOR4Tm$|FWs{=}G@rwVia^13NG6oVVO+!?}=3 zSLaXW;c2#ecDd#{w$o{+JNAXTT}gXpsbRHYuJR0}K~?vVF4IbX?DD zfXzv462+pp>_ya@Ef^~L>|0I+`~fY_p2(j$@o-@8w~$h&-l$}h4wLcwi&18on$xs0 zZpVh*%Up2WXEW4=0^xtM={pU}I4uumfbLfD9H&t>%QY)A-}7pYotZS?01sxm(^Hwc zU2b$LR;DFJaDW8~27)8@&!{nIoBp1GTo*e50-MX{52x;5D0OVFBTFMa-4W` z_|yXu#v6cyZ3CMbUIeHqyo~FJ(N(z}WF-FmGmLjf_}-y`*c#lGDZsuaMi{$<{6u2p zCy_!Txvb45#v|X|mPj5?j2utI=HlN5IWOdVoMF7jr62W9srF@fEu-w8H~S50eczmz zyXeKYxM)GQ-aMqSq0NBQG`4*Ue0U2ycr66u+k_>kq(Ohb#ao6T!Ljk} z46Rq}Ibh#_->tJUh93z1aNPTTczp}J131om88}jKWZj!fzTe$hVTav1VVfK^dh`~AQ0Ne;Yav9 zfr$t)z&xop;}F&u66ND-5KjtdkM)q3`h5z%B=!9Y{zIux zDfn-ten`RBrT&nD|3&IFKjrg=#0!f3`%*t6xw@{D#Ia_>b-SqGR42@6_nPnl1KfiT z3FI}BT&rOkp4Ii3Q87J}8Kric8Lop0nr98@X<>B+RP?D>rOpz3iBui%6tY<=xz_nj z!=`K6OBMw5EnIu4QEz)V!A6Ki-L}X8CL|HzqR`7uvuW9opbg(#2E3r*n+v|dq`qW# z4EP#rS+3WUajjah>Y7bUZpZ)4QV;>pfa;F|=A=OPfpDrv()WUZ{VPX+lcfsEkg0Nl@57#^n{2L#A2yMf302GY*RsFNzi!mqQ7bcqja2N!c<|m$$nCd?x z4OD+xKlx+7AQ{AfTnYXoKzu>9#lG5a|L@0(2s9!u5$-?sA)24||9gO`F#%#F>Gw-i zLZsT_pYJM$=EL$p#zVd+sAFh9Vx2yaA3SbzM)(N7ZBN!CuureX3#D4`g{ru0%PtuP> zl#K`Z5&!)b{^w*v!21;@@*{o)21yRvt*Q-04yv|q1CDhm%Pk18CjCEM!zI33h1(2@NST?BvgNFld{x6 d+Mqv6!<7w4Nb3IW0JNWfOXg2~jKZk?{{`I{k&FNU diff --git a/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/main.o b/build/temp.linux-x86_64-cpython-313/build/faster_hexbytes/main.o deleted file mode 100644 index 41dc0be36002681a3541b61a8b812b5d299ead6d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5280 zcmbVPZ){uD6~EWdk2rPWq%ET^U5Ud0K~+D;NtULC4o6OjTLH~lGEx|GpY7+^V87=* zKT~^~1|xJ*R3TO41DdoCljy#&sUL;}(lmv2Q@_BMN!yr&ph!p*M%7LGv<;~{=iYl> zUS1uvaTLFM&hPxW=iYnnc`wf$dHA6S=ZuK6Z?FxCP{vLtHu#)ib8I(DvVV@;@$aR= zONS9USy=rnc@??B*>&&f!b@Kl{MzNh+9e6E{h@G9JGn(10+9W~kYC!e}hJzrS6 zURayIE2aVg_qX3wtH#LKiLkNJLr+>ALjS)D$ZovO^>&pc46REx!CuhlEFx?T5* zRkQ6`Zn0){OFhqO7eQ&(ZFEKY0(aw!+&=?fo$(mP(DAVsA3=IEAc&I~(so1;)5dQV z@@yn2tH)9cn#P5$wK-)7JaN5JV0)Xs{Ry4B_>8eglrQVM zPemj8u=Zgjc1%Lr<>&+Y;G=r%Sd?pj?k?-Qq{aJ@k9>n;zQJF+Rh@rZAGRRMp!SOa zFUs|p_NVR(Ixh<7!oX_)-J@OU#y-+B$0AU{ytvpa&Rb@q;gs3Jqf4oL_CP8-WlR|p zsdUrp*w*0{%eLHl8AQ`9*A91QXVNp%sq_l`WmD@#({lJ?9}!)k-F?V06g(k<8Vtg`307{sw5xKflGX1hk} zx?_W)Tn)%?-my#jFFY_&TL3-Lv#ZbKJfxY(oZqs^w{dS(M` zj$(@_7R6OBqTFnOswjs?oC^2@TAV+UKXK$CvKI}c)TuWrnNWAhpvow-OwDOp8MkA@ z&SlOx?lT$cKR)w6+4P-+Wt^4=GeBRfc#hL3o8_97S?qZ=$IeU{aCiqY-I?i3-7Yse z6)V#c8dNZqo*EpnZ$^zlvy^)Ud|m7SFl-^8Ka{$6snoH(jw*@tOh<^5Kb)L4CZ_LG zFx+#fXKY_s`cOr9{ninq%W*64Nc?*z81IhqJwpSr^Kd(+0sE@ZFm?gQBZ<);M+%AL zsy3gPh5FZg_%VZ6tbA9YJ5_8ssdM%h1Z^iyhm-;|iU=)O0( zXnud*tkT%fWg_&_xF&LI|L)%D+GxV+AZ4=Sg+V~ zz`h2*n`dS0;1>Ae7Pz$q{$0Rv-it6I`Ddm|(ResN!Qhd_$KG&@SY|fb5=QkwDeU$Z$drkNq$`9?g1@QY6j)Ek-%=x*VV+cnb%kS|n9qI{ zr=@VRS0XzX!Y7pcvKlcC-cs7nR~1fi$eun$2&Z25RwxekIiz>w;O{fpUr{*ae@u3E_C}k@m^Kuaoa9c{+qsy<&es zqWHg&BK-FviSSEG&WG@~m0SqnR6i#a9$r^U;aCg7x?K+87nRJ6cCQJaEHHZT>40O6 zIM-^JhG%s>W>ieiWJamoW`^safaX~Px>``21rdEJR;jZB-yT&5JOyu-O0M1V9lfIU-;-lXd9&cAYjZd>z@T*j5!IvAkqA@K@fPFpT?ZR!v3?$AnZ@; zCx7f0!~^S7OM!p)5y^yYv9I>q|0G^epiy;+aR0I2(EPOjrvVGc1c;qhe!oN^Kw;Z9 z=)xG9532*22>2o!w#9$=`{jSHYSiS9`BTrqIF$bjz=va^{;-;#-iL@Gg>7HygQ49M z%Kr)q0Sf#71a$rKUsn0Qt9&tke7A@9|5d;+Can`#L5DCX5Y>^CHu9%Deg%qt{w}`k zfIgIi|0F*ee+!y^{wGyK!21;>@}u!GD2Wf+Jr`~$N*T8O3*cCns@(h#&ny3wk4T30 zkKpUTV9c=p&y|0T4AmI+{}k|k=Qn|e1w`k9=ZEin@~8UiH#hpla8W=P)q?T+9!nzZ kk8M(w8gLu*hBExo1|&EY&PTTc*U$g7%AfieIfVWH3oqV@6aWAK From 5b7bfcda2b177eeb4ca995730a3af33103e398e0 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 00:48:19 -0400 Subject: [PATCH 23/70] fix mypy err --- faster_hexbytes/main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index 476454a..7f5fad7 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -63,7 +63,7 @@ def __getitem__( # noqa: F811 cls = type(self) if cls is HexBytes: # fast-path case with faster C code for non-subclass - return HexBytes(result) + return HexBytes(result) # type: ignore [return-value] return cls(result) def __repr__(self) -> str: From 919d553d2002b2a93804285ececc36495c9c9fe6 Mon Sep 17 00:00:00 2001 From: BobTheBuidler Date: Tue, 30 Sep 2025 05:09:22 +0000 Subject: [PATCH 24/70] fix mypy err --- faster_hexbytes/main.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index 7f5fad7..ae9958a 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -8,7 +8,10 @@ overload, ) -import hexbytes +# 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 5f450b57e310e1556de2643e25ef4c8c70fff2b2 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 05:09:49 +0000 Subject: [PATCH 25/70] chore: compile C files for source control --- build/__native_6a32f4913d613d6a7ddf.c | 3101 +++++++++++++++++ build/__native_6a32f4913d613d6a7ddf.h | 72 + .../__native_internal_6a32f4913d613d6a7ddf.h | 78 + build/faster_hexbytes.c | 21 + build/faster_hexbytes/_utils.c | 21 + build/faster_hexbytes/main.c | 21 + build/ops.txt | 1466 ++++++++ 7 files changed, 4780 insertions(+) create mode 100644 build/__native_6a32f4913d613d6a7ddf.c create mode 100644 build/__native_6a32f4913d613d6a7ddf.h create mode 100644 build/__native_internal_6a32f4913d613d6a7ddf.h create mode 100644 build/faster_hexbytes.c create mode 100644 build/faster_hexbytes/_utils.c create mode 100644 build/faster_hexbytes/main.c create mode 100644 build/ops.txt diff --git a/build/__native_6a32f4913d613d6a7ddf.c b/build/__native_6a32f4913d613d6a7ddf.c new file mode 100644 index 0000000..7e84d32 --- /dev/null +++ b/build/__native_6a32f4913d613d6a7ddf.c @@ -0,0 +1,3101 @@ +#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[3]; /* '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[69]; /* ('version',) */ + cpy_r_r6 = CPyStatics[70]; /* ('__version',) */ + cpy_r_r7 = CPyStatics[6]; /* '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", "", 1, 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[71]; /* ('HexBytes',) */ + cpy_r_r11 = CPyStatics[8]; /* '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", "", 5, 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[7]; /* 'HexBytes' */ + cpy_r_r15 = PyList_New(1); + if (unlikely(cpy_r_r15 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", 9, 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[9]; /* '__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", "", 9, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + cpy_r_r22 = CPyStatics[10]; /* 'hexbytes' */ + cpy_r_r23 = CPyStatic_faster_hexbytes___globals; + cpy_r_r24 = CPyStatics[5]; /* '__version' */ + cpy_r_r25 = CPyDict_GetItem(cpy_r_r23, cpy_r_r24); + if (unlikely(cpy_r_r25 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", 11, 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", "", 11, 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[11]; /* '__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", "", 11, 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", 21, 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", 23, 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", 25, CPyStatic__utils___globals); + goto CPyL51; + } + if (!cpy_r_r12) goto CPyL15; + cpy_r_r13 = CPyStatics[67]; /* b'\x01' */ + CPy_INCREF(cpy_r_r13); + cpy_r_r14 = cpy_r_r13; + goto CPyL16; +CPyL15: ; + cpy_r_r15 = CPyStatics[68]; /* 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", 29, 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[12]; /* '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", 30, 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", 30, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r28 = CPyStatics[13]; /* ' 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", 30, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r30 = CPyModule_builtins; + cpy_r_r31 = CPyStatics[14]; /* '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", 30, 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", 30, 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", 30, 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", 32, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r37 = CPyModule_builtins; + cpy_r_r38 = CPyStatics[15]; /* '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", 32, 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", 32, 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", 32, CPyStatic__utils___globals); + goto CPyL51; + } + return cpy_r_r45; +CPyL37: ; + cpy_r_r46 = CPyModule_builtins; + cpy_r_r47 = CPyStatics[16]; /* '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", 33, 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", 33, 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", 34, 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[17]; /* '' */ + cpy_r_r58 = CPyStatics[18]; /* 'Cannot convert ' */ + cpy_r_r59 = CPyStatics[19]; /* '{!r:{}}' */ + cpy_r_r60 = CPyStatics[17]; /* '' */ + cpy_r_r61 = CPyStatics[20]; /* '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", 36, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r65 = CPyStatics[21]; /* ' of type ' */ + cpy_r_r66 = CPyStatics[22]; /* '{:{}}' */ + cpy_r_r67 = CPy_TYPE(cpy_r_val); + cpy_r_r68 = CPyStatics[17]; /* '' */ + cpy_r_r69 = CPyStatics[20]; /* '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", 36, CPyStatic__utils___globals); + goto CPyL55; + } + CPy_DECREF(cpy_r_r67); + cpy_r_r73 = CPyStatics[13]; /* ' to bytes' */ + cpy_r_r74 = PyList_New(5); + if (unlikely(cpy_r_r74 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 36, 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", 36, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r82 = CPyModule_builtins; + cpy_r_r83 = CPyStatics[23]; /* '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", 36, 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", 36, 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", 36, 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", 11, 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[24]; /* '0x' */ + cpy_r_r1 = CPyStatics[25]; /* '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", 40, 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", 41, 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", 46, 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", 46, 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[26]; /* '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", 47, 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", 52, 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[27]; /* '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", 53, 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[28]; /* 'hex string ' */ + cpy_r_r21 = CPyStatics[29]; /* ' 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", 55, CPyStatic__utils___globals); + goto CPyL23; + } + cpy_r_r23 = CPyModule_builtins; + cpy_r_r24 = CPyStatics[14]; /* '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", 54, 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", 54, 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", 54, 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", 58, 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", 58, 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", 39, 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[3]; /* '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[73]; /* (('binascii', 'binascii', 'binascii'),) */ + cpy_r_r11 = CPyStatic__utils___globals; + cpy_r_r12 = CPyStatics[31]; /* 'faster_hexbytes/_utils.py' */ + cpy_r_r13 = CPyStatics[32]; /* '' */ + 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[74]; /* ('Final', 'Union') */ + cpy_r_r16 = CPyStatics[35]; /* '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", "", 2, 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[36]; /* 'unhexlify' */ + cpy_r_r21 = CPyObject_GetAttr(cpy_r_r19, cpy_r_r20); + if (unlikely(cpy_r_r21 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "", 8, 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[36]; /* '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", "", 8, 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_____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__", 49, 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__", 50, 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__", 50, CPyStatic_main___globals); + goto CPyL9; + } + CPy_DECREF(cpy_r_r0); + if (likely(Py_TYPE(cpy_r_r5) == CPyType_main___HexBytes)) + cpy_r_r6 = cpy_r_r5; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__new__", 50, 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__", 48, 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[37]; /* '__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__", 63, 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__", 63, 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__", 65, 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__", 69, 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__", 69, CPyStatic_main___globals); + goto CPyL16; + } + CPy_DECREF(cpy_r_r12); + if (likely(Py_TYPE(cpy_r_r16) == CPyType_main___HexBytes)) + cpy_r_r17 = cpy_r_r16; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 69, 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__", 70, 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__", 70, CPyStatic_main___globals); + goto CPyL18; + } + CPy_DECREF(cpy_r_r18); + if (likely(Py_TYPE(cpy_r_r21) == CPyType_main___HexBytes)) + cpy_r_r22 = cpy_r_r21; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 70, 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(Py_TYPE(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__", 60, 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_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + 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_r13; + PyObject *cpy_r_r14; + PyObject *cpy_r_r15; + PyObject *cpy_r_r16; + PyObject *cpy_r_r17; + CPyPtr cpy_r_r18; + CPyPtr cpy_r_r19; + CPyPtr cpy_r_r20; + CPyPtr cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + cpy_r_r0 = CPyStatics[17]; /* '' */ + cpy_r_r1 = CPyStatics[38]; /* 'HexBytes(' */ + cpy_r_r2 = CPyStatics[19]; /* '{!r:{}}' */ + cpy_r_r3 = CPyStatics[24]; /* '0x' */ + cpy_r_r4 = CPyStatics[15]; /* 'hex' */ + PyObject *cpy_r_r5[1] = {cpy_r_self}; + cpy_r_r6 = (PyObject **)&cpy_r_r5; + cpy_r_r7 = PyObject_VectorcallMethod(cpy_r_r4, cpy_r_r6, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r7 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); + goto CPyL8; + } + if (likely(PyUnicode_Check(cpy_r_r7))) + cpy_r_r8 = cpy_r_r7; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals, "str", cpy_r_r7); + goto CPyL8; + } + cpy_r_r9 = PyUnicode_Concat(cpy_r_r3, cpy_r_r8); + CPy_DECREF(cpy_r_r8); + if (unlikely(cpy_r_r9 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); + goto CPyL8; + } + cpy_r_r10 = CPyStatics[17]; /* '' */ + cpy_r_r11 = CPyStatics[20]; /* 'format' */ + PyObject *cpy_r_r12[3] = {cpy_r_r2, cpy_r_r9, cpy_r_r10}; + cpy_r_r13 = (PyObject **)&cpy_r_r12; + cpy_r_r14 = PyObject_VectorcallMethod(cpy_r_r11, cpy_r_r13, 9223372036854775811ULL, 0); + if (unlikely(cpy_r_r14 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); + goto CPyL9; + } + CPy_DECREF(cpy_r_r9); + if (likely(PyUnicode_Check(cpy_r_r14))) + cpy_r_r15 = cpy_r_r14; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals, "str", cpy_r_r14); + goto CPyL8; + } + cpy_r_r16 = CPyStatics[39]; /* ')' */ + cpy_r_r17 = PyList_New(3); + if (unlikely(cpy_r_r17 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); + goto CPyL10; + } + cpy_r_r18 = (CPyPtr)&((PyListObject *)cpy_r_r17)->ob_item; + cpy_r_r19 = *(CPyPtr *)cpy_r_r18; + CPy_INCREF(cpy_r_r1); + *(PyObject * *)cpy_r_r19 = cpy_r_r1; + cpy_r_r20 = cpy_r_r19 + 8; + *(PyObject * *)cpy_r_r20 = cpy_r_r15; + CPy_INCREF(cpy_r_r16); + cpy_r_r21 = cpy_r_r19 + 16; + *(PyObject * *)cpy_r_r21 = cpy_r_r16; + cpy_r_r22 = PyUnicode_Join(cpy_r_r0, cpy_r_r17); + CPy_DECREF_NO_IMM(cpy_r_r17); + if (unlikely(cpy_r_r22 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); + goto CPyL8; + } + return cpy_r_r22; +CPyL8: ; + cpy_r_r23 = NULL; + return cpy_r_r23; +CPyL9: ; + CPy_DecRef(cpy_r_r9); + goto CPyL8; +CPyL10: ; + CPy_DecRef(cpy_r_r15); + goto CPyL8; +} + +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(Py_TYPE(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__", 72, 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[24]; /* '0x' */ + cpy_r_r1 = CPyStatics[15]; /* '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", 79, 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", 79, 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", 79, 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(Py_TYPE(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", 75, 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__", 89, 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__", 89, 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__", 89, 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(Py_TYPE(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__", 81, 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_r122; + PyObject *cpy_r_r123; + PyObject *cpy_r_r124; + PyObject **cpy_r_r126; + PyObject *cpy_r_r127; + PyObject *cpy_r_r128; + PyObject *cpy_r_r129; + int32_t cpy_r_r130; + char cpy_r_r131; + PyObject *cpy_r_r132; + char cpy_r_r133; + 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[3]; /* '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 CPyL48; + } + CPyModule_builtins = cpy_r_r4; + CPy_INCREF(CPyModule_builtins); + CPy_DECREF(cpy_r_r4); +CPyL3: ; + cpy_r_r5 = CPyStatics[75]; /* ('TYPE_CHECKING', 'Callable', 'Final', 'Tuple', 'Type', + 'Union', 'overload') */ + cpy_r_r6 = CPyStatics[35]; /* '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", "", 1, CPyStatic_main___globals); + goto CPyL48; + } + 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[77]; /* (('hexbytes.main', 'hexbytes.main', 'hexbytes'),) */ + cpy_r_r15 = CPyStatic_main___globals; + cpy_r_r16 = CPyStatics[46]; /* 'faster_hexbytes/main.py' */ + cpy_r_r17 = CPyStatics[32]; /* '' */ + 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 CPyL48; + cpy_r_r19 = CPyStatics[78]; /* ('mypyc_attr',) */ + cpy_r_r20 = CPyStatics[48]; /* '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", "", 15, CPyStatic_main___globals); + goto CPyL48; + } + CPyModule_mypy_extensions = cpy_r_r22; + CPy_INCREF(CPyModule_mypy_extensions); + CPy_DECREF(cpy_r_r22); + cpy_r_r23 = CPyStatics[79]; /* ('Self',) */ + cpy_r_r24 = CPyStatics[50]; /* '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", "", 18, CPyStatic_main___globals); + goto CPyL48; + } + CPyModule_typing_extensions = cpy_r_r26; + CPy_INCREF(CPyModule_typing_extensions); + CPy_DECREF(cpy_r_r26); + cpy_r_r27 = CPyStatics[80]; /* ('to_bytes',) */ + cpy_r_r28 = CPyStatics[52]; /* '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", "", 22, CPyStatic_main___globals); + goto CPyL48; + } + 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[34]; /* 'Union' */ + cpy_r_r33 = CPyDict_GetItem(cpy_r_r31, cpy_r_r32); + if (unlikely(cpy_r_r33 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 31, CPyStatic_main___globals); + goto CPyL48; + } + 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[53]; /* 'bytearray' */ + cpy_r_r39 = CPyObject_GetAttr(cpy_r_r37, cpy_r_r38); + if (unlikely(cpy_r_r39 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 31, CPyStatic_main___globals); + goto CPyL49; + } + cpy_r_r40 = (PyObject *)&PyLong_Type; + cpy_r_r41 = CPyModule_builtins; + cpy_r_r42 = CPyStatics[16]; /* 'memoryview' */ + cpy_r_r43 = CPyObject_GetAttr(cpy_r_r41, cpy_r_r42); + if (unlikely(cpy_r_r43 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 31, CPyStatic_main___globals); + goto CPyL50; + } + 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", "", 31, CPyStatic_main___globals); + goto CPyL48; + } + cpy_r_r47 = CPyStatic_main___globals; + cpy_r_r48 = CPyStatics[54]; /* '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", "", 31, CPyStatic_main___globals); + goto CPyL48; + } + cpy_r_r51 = (PyObject *)&PyBytes_Type; + cpy_r_r52 = CPyStatics[55]; /* '__new__' */ + cpy_r_r53 = CPyObject_GetAttr(cpy_r_r51, cpy_r_r52); + if (unlikely(cpy_r_r53 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 33, CPyStatic_main___globals); + goto CPyL48; + } + CPyStatic_main____bytes_new = cpy_r_r53; + CPy_INCREF(CPyStatic_main____bytes_new); + cpy_r_r54 = CPyStatic_main___globals; + cpy_r_r55 = CPyStatics[56]; /* '_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", "", 33, CPyStatic_main___globals); + goto CPyL48; + } + cpy_r_r58 = CPyModule_hexbytes___main; + cpy_r_r59 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r60 = CPyObject_GetAttr(cpy_r_r58, cpy_r_r59); + if (unlikely(cpy_r_r60 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); + goto CPyL48; + } + 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", "", 37, CPyStatic_main___globals); + goto CPyL48; + } + 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", "", 37, CPyStatic_main___globals); + goto CPyL51; + } + cpy_r_r64 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r65 = PyObject_HasAttr(cpy_r_r63, cpy_r_r64); + if (!cpy_r_r65) goto CPyL24; + cpy_r_r66 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r67 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r68 = CPyObject_GetAttr(cpy_r_r63, cpy_r_r67); + if (unlikely(cpy_r_r68 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); + goto CPyL51; + } + 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", "", 37, CPyStatic_main___globals); + goto CPyL51; + } + if (likely(PyDict_Check(cpy_r_r71))) + cpy_r_r72 = cpy_r_r71; + else { + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals, "dict", cpy_r_r71); + goto CPyL51; + } + 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", "", 37, CPyStatic_main___globals); + goto CPyL51; + } + cpy_r_r73 = cpy_r_r74; +CPyL26: ; + cpy_r_r75 = PyDict_New(); + if (unlikely(cpy_r_r75 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); + goto CPyL52; + } + cpy_r_r76 = CPyDef_main_____new___3_HexBytes_obj(); + if (unlikely(cpy_r_r76 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 48, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r77 = CPyModule_builtins; + cpy_r_r78 = CPyStatics[58]; /* 'staticmethod' */ + cpy_r_r79 = CPyObject_GetAttr(cpy_r_r77, cpy_r_r78); + if (unlikely(cpy_r_r79 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 48, CPyStatic_main___globals); + goto CPyL54; + } + 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", "", 48, CPyStatic_main___globals); + goto CPyL54; + } + CPy_DECREF_NO_IMM(cpy_r_r76); + cpy_r_r83 = CPyStatics[55]; /* '__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", "", 48, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r86 = CPyDef_main_____getitem___3_HexBytes_obj(); + if (unlikely(cpy_r_r86 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 60, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r87 = CPyStatics[37]; /* '__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", "", 60, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r90 = CPyDef_main_____repr___3_HexBytes_obj(); + if (unlikely(cpy_r_r90 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 72, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r91 = CPyStatics[59]; /* '__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", "", 72, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r94 = CPyDef_main___to_0x_hex_HexBytes_obj(); + if (unlikely(cpy_r_r94 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 75, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r95 = CPyStatics[60]; /* '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", "", 75, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r98 = CPyDef_main_____reduce___3_HexBytes_obj(); + if (unlikely(cpy_r_r98 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 81, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r99 = CPyStatics[61]; /* '__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", "", 81, CPyStatic_main___globals); + goto CPyL53; + } + cpy_r_r102 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r103 = CPyStatics[62]; /* '__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", "", 37, CPyStatic_main___globals); + goto CPyL52; + } + cpy_r_r106 = CPyStatics[63]; /* 'mypyc filler docstring' */ + cpy_r_r107 = CPyStatics[64]; /* '__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", "", 37, CPyStatic_main___globals); + goto CPyL52; + } + cpy_r_r110 = CPyStatics[8]; /* 'faster_hexbytes.main' */ + cpy_r_r111 = CPyStatics[65]; /* '__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", "", 37, CPyStatic_main___globals); + goto CPyL52; + } + 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", "", 37, CPyStatic_main___globals); + goto CPyL52; + } + CPy_DECREF(cpy_r_r73); + CPy_DECREF(cpy_r_r61); + cpy_r_r117 = CPyStatic_main___globals; + cpy_r_r118 = CPyStatics[47]; /* '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", "", 36, CPyStatic_main___globals); + goto CPyL55; + } + cpy_r_r120 = 0 ? Py_True : Py_False; + PyObject *cpy_r_r121[1] = {cpy_r_r120}; + cpy_r_r122 = (PyObject **)&cpy_r_r121; + cpy_r_r123 = CPyStatics[81]; /* ('native_class',) */ + cpy_r_r124 = PyObject_Vectorcall(cpy_r_r119, cpy_r_r122, 0, cpy_r_r123); + CPy_DECREF(cpy_r_r119); + if (unlikely(cpy_r_r124 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 36, CPyStatic_main___globals); + goto CPyL55; + } + PyObject *cpy_r_r125[1] = {cpy_r_r116}; + cpy_r_r126 = (PyObject **)&cpy_r_r125; + cpy_r_r127 = PyObject_Vectorcall(cpy_r_r124, cpy_r_r126, 1, 0); + CPy_DECREF(cpy_r_r124); + if (unlikely(cpy_r_r127 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); + goto CPyL55; + } + CPy_DECREF(cpy_r_r116); + CPyType_main___HexBytes = (PyTypeObject *)cpy_r_r127; + CPy_INCREF(CPyType_main___HexBytes); + cpy_r_r128 = CPyStatic_main___globals; + cpy_r_r129 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r130 = PyDict_SetItem(cpy_r_r128, cpy_r_r129, cpy_r_r127); + CPy_DECREF(cpy_r_r127); + cpy_r_r131 = cpy_r_r130 >= 0; + if (unlikely(!cpy_r_r131)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); + goto CPyL48; + } + cpy_r_r132 = (PyObject *)CPyType_main___HexBytes; + return 1; +CPyL48: ; + cpy_r_r133 = 2; + return cpy_r_r133; +CPyL49: ; + CPy_DecRef(cpy_r_r33); + goto CPyL48; +CPyL50: ; + CPy_DecRef(cpy_r_r33); + CPy_DecRef(cpy_r_r39); + goto CPyL48; +CPyL51: ; + CPy_DecRef(cpy_r_r61); + goto CPyL48; +CPyL52: ; + CPy_DecRef(cpy_r_r61); + CPy_DecRef(cpy_r_r73); + goto CPyL48; +CPyL53: ; + CPy_DecRef(cpy_r_r61); + CPy_DecRef(cpy_r_r73); + CPy_DecRef(cpy_r_r75); + goto CPyL48; +CPyL54: ; + CPy_DecRef(cpy_r_r61); + CPy_DecRef(cpy_r_r73); + CPy_DecRef(cpy_r_r75); + CPy_DecRef(cpy_r_r76); + goto CPyL48; +CPyL55: ; + CPy_DecRef(cpy_r_r116); + goto CPyL48; +} + +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[82]; +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", + "\b\v__getitem__\tHexBytes(\001)\rTYPE_CHECKING\bCallable\005Tuple\004Type\boverload", + "\005\rhexbytes.main\027faster_hexbytes/main.py\nmypyc_attr\017mypy_extensions\004Self", + "\005\021typing_extensions\bto_bytes\026faster_hexbytes._utils\tbytearray\tBytesLike", + "\006\a__new__\n_bytes_new\v__prepare__\fstaticmethod\b__repr__\tto_0x_hex", + "\005\n__reduce__\017__annotations__\026mypyc filler docstring\a__doc__\n__module__", + "\001\fnative_class", + "", +}; +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[] = { + 13, 1, 4, 1, 5, 1, 7, 3, 30, 30, 30, 1, 72, 2, 33, 34, 7, 40, 41, + 33, 42, 43, 34, 44, 3, 45, 45, 10, 1, 76, 1, 47, 1, 49, 1, 51, 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_____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..84b1a09 --- /dev/null +++ b/build/__native_internal_6a32f4913d613d6a7ddf.h @@ -0,0 +1,78 @@ +#ifndef MYPYC_NATIVE_INTERNAL_6a32f4913d613d6a7ddf_H +#define MYPYC_NATIVE_INTERNAL_6a32f4913d613d6a7ddf_H +#include +#include +#include "__native_6a32f4913d613d6a7ddf.h" + +int CPyGlobalsInit(void); + +extern PyObject *CPyStatics[82]; +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_____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..c09d246 --- /dev/null +++ b/build/faster_hexbytes.c @@ -0,0 +1,21 @@ +#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..5ed32ca --- /dev/null +++ b/build/ops.txt @@ -0,0 +1,1466 @@ +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 + +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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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__:63) else goto L1 +L1: + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) 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__:65) 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__:69) 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__:69) else goto L8 +L8: + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 +L9: + return r17 +L10: + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 +L12: + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) 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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:73) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:73) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) + dec_ref r8 + if is_error(r9) goto L8 (error at __repr__:73) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] + r13 = load_address r12 + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:73) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:73) else goto L5 +L5: + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:73) else goto L6 +L6: + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:73) else goto L7 +L7: + return r22 +L8: + r23 = :: str + return r23 +L9: + dec_ref r9 + goto L8 +L10: + dec_ref r15 + goto L8 + +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:79) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 +L2: + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) 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__:89) 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__:89) else goto L4 +L4: + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) 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 :: object + r121 :: object[1] + r122 :: object_ptr + r123, r124 :: object + r125 :: object[1] + r126 :: object_ptr + r127 :: object + r128 :: dict + r129 :: str + r130 :: i32 + r131 :: bit + r132 :: object + r133 :: 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 L48 (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 L48 (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 L48 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 L48 (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 L48 (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 L48 (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 L48 (error at :31) 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 L49 (error at :31) else goto L11 +L11: + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) 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 L48 (error at :31) 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 L48 (error at :31) else goto L14 :: bool +L14: + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) 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 L48 (error at :33) else goto L16 :: bool +L16: + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) else goto L17 +L17: + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) else goto L18 +L18: + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 +L22: + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 +L23: + r73 = r72 + goto L26 +L24: + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 +L25: + r73 = r74 +L26: + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 +L27: + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 +L28: + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool +L31: + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 +L32: + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool +L33: + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 +L34: + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool +L35: + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool +L37: + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 +L38: + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type + return 1 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 From 38f05f2ddb5d21c1ee0b719c3b155b0e91988b64 Mon Sep 17 00:00:00 2001 From: BobTheBuidler Date: Tue, 30 Sep 2025 06:21:29 +0000 Subject: [PATCH 26/70] benchmarks --- .github/workflows/benchmark.yaml | 113 ++++++++++ .github/workflows/codspeed.yaml | 32 +++ benchmarks/params.py | 193 ++++++++++++++++++ benchmarks/test__utils_benchmarks.py | 32 +++ benchmarks/test_main_benchmarks.py | 76 +++++++ .../benchmark/compare_benchmark_results.py | 94 +++++++++ .../benchmark/generate_benchmark_markdown.py | 62 ++++++ scripts/benchmark/parse_benchmark_output.py | 78 +++++++ 8 files changed, 680 insertions(+) create mode 100644 .github/workflows/benchmark.yaml create mode 100644 .github/workflows/codspeed.yaml create mode 100644 benchmarks/params.py create mode 100644 benchmarks/test__utils_benchmarks.py create mode 100644 benchmarks/test_main_benchmarks.py create mode 100644 scripts/benchmark/compare_benchmark_results.py create mode 100644 scripts/benchmark/generate_benchmark_markdown.py create mode 100644 scripts/benchmark/parse_benchmark_output.py diff --git a/.github/workflows/benchmark.yaml b/.github/workflows/benchmark.yaml new file mode 100644 index 0000000..50a0b8e --- /dev/null +++ b/.github/workflows/benchmark.yaml @@ -0,0 +1,113 @@ +name: Pytest Benchmarks + +on: + pull_request: + branches: [master] + push: + branches: [master] + 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] + pip install pytest-codspeed pytest-benchmark 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..505921c --- /dev/null +++ b/.github/workflows/codspeed.yaml @@ -0,0 +1,32 @@ +name: CodSpeed Benchmarks + +on: + pull_request: + branches: [master] + push: + branches: [master] + 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] + pip install pytest-codspeed hexbytes + - name: Run CodSpeed + uses: CodSpeedHQ/action@v3 + with: + run: pytest --codspeed -k "test_faster_" benchmarks/ diff --git a/benchmarks/params.py b/benchmarks/params.py new file mode 100644 index 0000000..5dcf67c --- /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"), + ("unicode-✓-测试", "unicode string"), + ("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"), + (-1, "-1"), + (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/test__utils_benchmarks.py b/benchmarks/test__utils_benchmarks.py new file mode 100644 index 0000000..e40d538 --- /dev/null +++ b/benchmarks/test__utils_benchmarks.py @@ -0,0 +1,32 @@ +from typing import Any + +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, +) + +@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(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(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(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(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..2a7d217 --- /dev/null +++ b/benchmarks/test_main_benchmarks.py @@ -0,0 +1,76 @@ +from typing import Any + +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, +) + +@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(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(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(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(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(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(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(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(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(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(obj.to_0x_hex) diff --git a/scripts/benchmark/compare_benchmark_results.py b/scripts/benchmark/compare_benchmark_results.py new file mode 100644 index 0000000..5f5fa01 --- /dev/null +++ b/scripts/benchmark/compare_benchmark_results.py @@ -0,0 +1,94 @@ +""" +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..3d3aed7 --- /dev/null +++ b/scripts/benchmark/generate_benchmark_markdown.py @@ -0,0 +1,62 @@ +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() From f2931412dff5359f1ee6fa60212adf523f5cb215 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 06:22:27 +0000 Subject: [PATCH 27/70] chore: compile C files for source control --- build/ops.txt | 2290 ++++++++++++++++++++++++------------------------- 1 file changed, 1145 insertions(+), 1145 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 5ed32ca..a8ead04 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -101,644 +101,326 @@ 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 +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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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 :: 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 + 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 = PyBytes_Check(val) - if r0 goto L1 else goto L3 :: bool + 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__:63) else goto L1 L1: - inc_ref val - r1 = cast(bytes, val) - if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 L2: - return r1 + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool L3: - r2 = PyUnicode_Check(val) - if r2 goto L4 else goto L7 :: bool + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 L4: - inc_ref val - r3 = cast(str, val) - if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 + r8 = box(int, r7) + return r8 L5: - r4 = hexstr_to_bytes(r3) - dec_ref r3 - if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool L6: - return r4 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - r5 = PyByteArray_Check(val) - if r5 goto L8 else goto L11 :: bool + 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__:69) else goto L8 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 + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 L9: - r10 = cast(bytes, r9) - if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 + return r17 L10: - return r10 + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 L11: - r11 = PyBool_Check(val) - if r11 goto L12 else goto L17 :: bool + 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__:70) else goto L12 L12: - r12 = unbox(bool, val) - if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 L13: - if r12 goto L14 else goto L15 :: bool + return r22 L14: - r13 = b'\x01' - inc_ref r13 - r14 = r13 - goto L16 -L15: - r15 = b'\x00' - inc_ref r15 - r14 = r15 + r23 = :: union[int, faster_hexbytes.main.HexBytes] + return r23 +L15: + dec_ref r9 + goto L6 L16: - return r14 + dec_ref r12 + goto L14 L17: - r16 = PyLong_Check(val) - if r16 goto L18 else goto L37 :: bool + dec_ref r9 + goto L14 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 + dec_ref r18 + goto L14 -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 +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - if r4 goto L2 else goto L5 :: bool + inc_ref __mypyc_self__ + return __mypyc_self__ 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 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 +L3: + return r2 L4: - non_prefixed_hex = r6 - goto L6 + 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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:73) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:73) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) + dec_ref r8 + if is_error(r9) goto L8 (error at __repr__:73) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] + r13 = load_address r12 + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:73) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:73) else goto L5 L5: - inc_ref hexstr - non_prefixed_hex = hexstr + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:73) else goto L6 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 + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:73) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + return r22 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + r23 = :: str + return r23 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 + dec_ref r9 + goto L8 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 + goto L8 -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 +def to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L8 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 - -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 + 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 +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 = to_bytes(val) - if is_error(r0) goto L7 (error at __new__:49) else goto L1 + 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:79) else goto L1 L1: - r1 = faster_hexbytes.main._bytes_new :: static - if is_error(r1) goto L8 else goto L4 + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 L2: - r2 = raise NameError('value for final name "_bytes_new" was not set') - if not r2 goto L7 (error at __new__:50) else goto L3 :: bool + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) else goto L3 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) else goto L6 -L6: return r6 -L7: - r7 = :: faster_hexbytes.main.HexBytes +L4: + r7 = :: str return r7 -L8: - dec_ref r0 - goto L2 -L9: - dec_ref r0 - goto L7 -def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): +def __reduce___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit r2, r3 :: object @@ -758,317 +440,61 @@ L4: r3 = :: object return r3 -def __getitem___HexBytes_obj.__call__(__mypyc_self__, self, key): - __mypyc_self__ :: faster_hexbytes.main.__getitem___HexBytes_obj +def __reduce___HexBytes_obj.__call__(__mypyc_self__, self): + __mypyc_self__ :: faster_hexbytes.main.__reduce___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] + 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 = 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__:63) else goto L1 + r0 = faster_hexbytes.main._bytes_new :: static + if is_error(r0) goto L1 else goto L3 L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 + r1 = raise NameError('value for final name "_bytes_new" was not set') + if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool L2: - r6 = PyLong_Check(r5) - if r6 goto L3 else goto L5 :: bool + unreachable L3: - r7 = unbox(int, r5) - dec_ref r5 - if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 + 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__:89) else goto L4 L4: - r8 = box(int, r7) - return r8 + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 L5: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + r8 = (r2, r7) + inc_ref r0 + r9 = (r0, r8) + return r9 L6: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + r10 = :: tuple[object, tuple[object, bytes]] + return r10 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__:69) else goto L8 -L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 -L9: - return r17 -L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 -L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 -L13: - return r22 -L14: - r23 = :: union[int, faster_hexbytes.main.HexBytes] - return r23 -L15: - dec_ref r9 + dec_ref r2 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, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str -L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:73) else goto L1 -L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:73) else goto L2 -L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:73) else goto L3 -L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:73) else goto L4 -L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:73) else goto L5 -L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:73) else goto L6 -L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:73) else goto L7 -L7: - return r22 -L8: - r23 = :: str - return r23 -L9: - dec_ref r9 - goto L8 -L10: - dec_ref r15 - goto L8 - -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:79) else goto L1 -L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 -L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) 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__:89) 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__:89) else goto L4 -L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) 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 +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 @@ -1170,297 +596,871 @@ def __top_level__(): r132 :: object r133 :: None L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + 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 L48 (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 L48 (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 L48 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 L48 (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 L48 (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 L48 (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 L48 (error at :31) 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 L49 (error at :31) else goto L11 +L11: + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) 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 L48 (error at :31) 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 L48 (error at :31) else goto L14 :: bool +L14: + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) 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 L48 (error at :33) else goto L16 :: bool +L16: + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) else goto L17 +L17: + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) else goto L18 +L18: + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 +L22: + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 +L23: + r73 = r72 + goto L26 +L24: + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 +L25: + r73 = r74 +L26: + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 +L27: + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 +L28: + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool +L31: + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 +L32: + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool +L33: + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 +L34: + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool +L35: + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool +L37: + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 +L38: + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type + return 1 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 + +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: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L48 (error at :-1) else goto L2 + if r4 goto L2 else goto L5 :: bool L2: - builtins = r4 :: module - dec_ref r4 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 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 L48 (error at :1) else goto L4 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) 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 L48 else goto L5 :: bool + non_prefixed_hex = r6 + goto L6 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 L48 (error at :15) else goto L6 + inc_ref hexstr + non_prefixed_hex = hexstr 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 L48 (error at :18) else goto L7 + 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: - 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 L48 (error at :22) else goto L8 + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 L8: - faster_hexbytes._utils = r30 :: module - dec_ref r30 - if 0 goto L9 else goto L9 :: bool + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool L9: - r31 = faster_hexbytes.main.globals :: static - r32 = 'Union' - r33 = CPyDict_GetItem(r31, r32) - if is_error(r33) goto L48 (error at :31) else goto L10 + 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: - 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 L49 (error at :31) else goto L11 + padded_hex = r13 + goto L12 L11: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) else goto L12 + padded_hex = non_prefixed_hex 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 L48 (error at :31) else goto L13 + r14 = PyUnicode_AsASCIIString(padded_hex) + if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 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 L48 (error at :31) else goto L14 :: bool + goto L25 L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) else goto L15 + 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: - 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 L48 (error at :33) else goto L16 :: bool + r19 = CPy_ExceptionMatches(r18) + dec_ref r18 + if r19 goto L16 else goto L35 :: bool L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 + 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: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 + 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: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) else goto L19 + 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: - r64 = '__prepare__' - r65 = PyObject_HasAttr(r63, r64) - if r65 goto L20 else goto L24 :: bool + 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: - r66 = 'HexBytes' - r67 = '__prepare__' - r68 = CPyObject_GetAttr(r63, r67) - if is_error(r68) goto L51 (error at :37) 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 L51 (error at :37) else goto L22 + unreachable +L21: + CPy_Reraise() + if not 0 goto L23 else goto L38 :: bool L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 + unreachable L23: - r73 = r72 - goto L26 + CPy_RestoreExcInfo(r15) + dec_ref r15 + r29 = CPy_KeepPropagating() + if not r29 goto L31 else goto L24 :: bool L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 + unreachable L25: - r73 = r74 + r30 = faster_hexbytes._utils.unhexlify :: static + if is_error(r30) goto L39 else goto L28 L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 + 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: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 + unreachable L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) else goto L29 + 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: - r80 = [r76] - r81 = load_address r80 - r82 = PyObject_Vectorcall(r79, r81, 1, 0) - dec_ref r79 - if is_error(r82) goto L54 (error at :48) else goto L30 + dec_ref r14 + r35 = cast(bytes, r34) + if is_error(r35) goto L31 (error at hexstr_to_bytes:58) 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 L53 (error at :48) else goto L31 :: bool + return r35 L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 + r36 = :: bytes + return r36 L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool + dec_ref non_prefixed_hex + goto L31 L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 + dec_ref padded_hex + goto L13 L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool + dec_ref padded_hex + goto L23 L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) else goto L36 + dec_ref padded_hex + goto L21 L36: - r95 = 'to_0x_hex' - r96 = CPyDict_SetItem(r73, r95, r94) - dec_ref r94 - r97 = r96 >= 0 :: signed - if not r97 goto L53 (error at :75) else goto L37 :: bool + dec_ref r22 + goto L23 L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 + dec_ref r15 + goto L20 L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) else goto L39 :: bool + dec_ref r15 + goto L22 L39: - r102 = 'HexBytes' - r103 = '__annotations__' - r104 = CPyDict_SetItem(r73, r103, r75) - dec_ref r75 - r105 = r104 >= 0 :: signed - if not r105 goto L52 (error at :37) else goto L40 :: bool + dec_ref r14 + goto L26 L40: - r106 = 'mypyc filler docstring' - r107 = '__doc__' - r108 = CPyDict_SetItem(r73, r107, r106) - r109 = r108 >= 0 :: signed - if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type + 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 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 +L8: + r26 = :: None + return r26 From 93b9fe440f3854d9cf0a7842f1485c38f066beee Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 02:24:58 -0400 Subject: [PATCH 28/70] Create __init__.py --- benchmarks/__init__.py | 1 + 1 file changed, 1 insertion(+) create mode 100644 benchmarks/__init__.py 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 @@ + From a7e70a2c4de20e43a19637419dbb2c440ba80247 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 06:25:22 +0000 Subject: [PATCH 29/70] chore: compile C files for source control --- build/ops.txt | 2458 ++++++++++++++++++++++++------------------------- 1 file changed, 1229 insertions(+), 1229 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index a8ead04..5ed32ca 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -101,326 +101,644 @@ L12: r34 = :: None return r34 -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__:49) 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__:50) 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) 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 +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 :: 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] + 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 = 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__:63) else goto L1 + r0 = PyBytes_Check(val) + if r0 goto L1 else goto L3 :: bool L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 + inc_ref val + r1 = cast(bytes, val) + if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 L2: - r6 = PyLong_Check(r5) - if r6 goto L3 else goto L5 :: bool + return r1 L3: - r7 = unbox(int, r5) - dec_ref r5 - if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 + r2 = PyUnicode_Check(val) + if r2 goto L4 else goto L7 :: bool L4: - r8 = box(int, r7) - return r8 + inc_ref val + r3 = cast(str, val) + if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 L5: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + r4 = hexstr_to_bytes(r3) + dec_ref r3 + if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 L6: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + return r4 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__:69) else goto L8 + r5 = PyByteArray_Check(val) + if r5 goto L8 else goto L11 :: bool L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 + 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: - return r17 + r10 = cast(bytes, r9) + if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 + return r10 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__:70) else goto L12 + r11 = PyBool_Check(val) + if r11 goto L12 else goto L17 :: bool L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 + r12 = unbox(bool, val) + if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 L13: - return r22 + if r12 goto L14 else goto L15 :: bool L14: - r23 = :: union[int, faster_hexbytes.main.HexBytes] - return r23 -L15: - dec_ref r9 - goto L6 + r13 = b'\x01' + inc_ref r13 + r14 = r13 + goto L16 +L15: + r15 = b'\x00' + inc_ref r15 + r14 = r15 L16: - dec_ref r12 - goto L14 + return r14 L17: - dec_ref r9 - goto L14 + r16 = PyLong_Check(val) + if r16 goto L18 else goto L37 :: bool L18: - dec_ref r18 - goto L14 + 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 __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + 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: - inc_ref __mypyc_self__ - return __mypyc_self__ + if r4 goto L2 else goto L5 :: bool 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, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str -L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:73) else goto L1 -L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:73) else goto L2 -L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:73) else goto L3 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:73) else goto L4 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:73) else goto L5 + non_prefixed_hex = r6 + goto L6 L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:73) else goto L6 + inc_ref hexstr + non_prefixed_hex = hexstr L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:73) else goto L7 + 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: - return r22 + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 L8: - r23 = :: str - return r23 + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool L9: - dec_ref r9 - goto L8 + 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 - goto L8 + 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 to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - inc_ref __mypyc_self__ - return __mypyc_self__ + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L8 (error at :-1) else goto L2 L2: - r2 = PyMethod_New(__mypyc_self__, instance) - if is_error(r2) goto L4 else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - return r2 + 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: - 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 + 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 + +def __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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:79) else goto L1 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) else goto L3 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 L3: - return r6 + return r2 L4: - r7 = :: str + 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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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 __reduce___HexBytes_obj.__get__(__mypyc_self__, instance, owner): +def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit r2, r3 :: object @@ -440,1027 +758,709 @@ L4: r3 = :: object return r3 -def __reduce___HexBytes_obj.__call__(__mypyc_self__, self): - __mypyc_self__ :: faster_hexbytes.main.__reduce___HexBytes_obj +def __getitem___HexBytes_obj.__call__(__mypyc_self__, self, key): + __mypyc_self__ :: faster_hexbytes.main.__getitem___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]] + 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 = faster_hexbytes.main._bytes_new :: static - if is_error(r0) goto L1 else goto L3 + 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__:63) else goto L1 L1: - r1 = raise NameError('value for final name "_bytes_new" was not set') - if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 L2: - unreachable + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool 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__:89) else goto L4 + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 + r8 = box(int, r7) + return r8 L5: - r8 = (r2, r7) - inc_ref r0 - r9 = (r0, r8) - return r9 + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool L6: - r10 = :: tuple[object, tuple[object, bytes]] - return r10 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - dec_ref r2 + 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__:69) else goto L8 +L8: + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 +L9: + return r17 +L10: + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 +L12: + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) 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 __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 :: object - r121 :: object[1] - r122 :: object_ptr - r123, r124 :: object - r125 :: object[1] - r126 :: object_ptr - r127 :: object - r128 :: dict - r129 :: str - r130 :: i32 - r131 :: bit - r132 :: object - r133 :: None +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L48 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 L48 (error at :1) else goto L4 + return r2 L4: - typing = r8 :: module + 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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:73) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:73) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) dec_ref r8 - r9 = load_address hexbytes.main :: module - r10 = [r9] - r11 = load_address r10 - r12 = [14] + if is_error(r9) goto L8 (error at __repr__:73) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] 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 L48 else goto L5 :: bool + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:73) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:73) else goto L5 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 L48 (error at :15) else goto L6 + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:73) 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 L48 (error at :18) else goto L7 + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:73) 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 L48 (error at :22) else goto L8 + return r22 L8: - faster_hexbytes._utils = r30 :: module - dec_ref r30 - if 0 goto L9 else goto L9 :: bool + r23 = :: str + return r23 L9: - r31 = faster_hexbytes.main.globals :: static - r32 = 'Union' - r33 = CPyDict_GetItem(r31, r32) - if is_error(r33) goto L48 (error at :31) else goto L10 + dec_ref r9 + goto L8 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 L49 (error at :31) else goto L11 -L11: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) 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 L48 (error at :31) 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 L48 (error at :31) else goto L14 :: bool -L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) 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 L48 (error at :33) else goto L16 :: bool -L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 -L17: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 -L18: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 -L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 -L23: - r73 = r72 - goto L26 -L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 -L25: - r73 = r74 -L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 -L27: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 -L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool -L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 -L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool -L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 -L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool -L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool -L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 -L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type - return 1 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 - -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: + dec_ref r15 + goto L8 + +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:79) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 +L2: + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) 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__:89) else goto L2 :: bool +L2: 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 +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__:89) else goto L4 +L4: + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) 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 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 +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 :: object - r26 :: object[1] - r27 :: object_ptr - r28 :: object - r29 :: bit + r25 :: dict + r26, r27 :: object + r28 :: str + r29 :: dict r30 :: object - r31 :: bool - r32 :: object[1] - r33 :: object_ptr - r34 :: object - r35, r36 :: bytes + 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 :: object + r121 :: object[1] + r122 :: object_ptr + r123, r124 :: object + r125 :: object[1] + r126 :: object_ptr + r127 :: object + r128 :: dict + r129 :: str + r130 :: i32 + r131 :: bit + r132 :: object + r133 :: None 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 + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - if r4 goto L2 else goto L5 :: bool + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L48 (error at :-1) else goto L2 L2: - r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) - if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - r6 = cast(str, r5) - if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 + 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 L48 (error at :1) else goto L4 L4: - non_prefixed_hex = r6 - goto L6 + 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 L48 else goto L5 :: bool L5: - inc_ref hexstr - non_prefixed_hex = hexstr + r19 = ('mypyc_attr',) + r20 = 'mypy_extensions' + r21 = faster_hexbytes.main.globals :: static + r22 = CPyImport_ImportFromMany(r20, r19, r19, r21) + if is_error(r22) goto L48 (error at :15) else goto L6 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 + 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 L48 (error at :18) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + 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 L48 (error at :22) else goto L8 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + faster_hexbytes._utils = r30 :: module + dec_ref r30 + if 0 goto L9 else goto L9 :: 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 + r31 = faster_hexbytes.main.globals :: static + r32 = 'Union' + r33 = CPyDict_GetItem(r31, r32) + if is_error(r33) goto L48 (error at :31) else goto L10 L10: - padded_hex = r13 - goto L12 + 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 L49 (error at :31) else goto L11 L11: - padded_hex = non_prefixed_hex + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) else goto L12 L12: - r14 = PyUnicode_AsASCIIString(padded_hex) - if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 + 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 L48 (error at :31) else goto L13 L13: - goto L25 + 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 L48 (error at :31) else goto L14 :: bool 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 + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) else goto L15 L15: - r19 = CPy_ExceptionMatches(r18) - dec_ref r18 - if r19 goto L16 else goto L35 :: bool + 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 L48 (error at :33) else goto L16 :: 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 + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) 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 + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) 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 + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 + r64 = '__prepare__' + r65 = PyObject_HasAttr(r63, r64) + if r65 goto L20 else goto L24 :: bool L20: - unreachable + r66 = 'HexBytes' + r67 = '__prepare__' + r68 = CPyObject_GetAttr(r63, r67) + if is_error(r68) goto L51 (error at :37) else goto L21 L21: - CPy_Reraise() - if not 0 goto L23 else goto L38 :: bool + r69 = [r66, r61] + r70 = load_address r69 + r71 = PyObject_Vectorcall(r68, r70, 2, 0) + dec_ref r68 + if is_error(r71) goto L51 (error at :37) else goto L22 L22: - unreachable + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 L23: - CPy_RestoreExcInfo(r15) - dec_ref r15 - r29 = CPy_KeepPropagating() - if not r29 goto L31 else goto L24 :: bool + r73 = r72 + goto L26 L24: - unreachable + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 L25: - r30 = faster_hexbytes._utils.unhexlify :: static - if is_error(r30) goto L39 else goto L28 + r73 = r74 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 + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 L27: - unreachable + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 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 + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 + r80 = [r76] + r81 = load_address r80 + r82 = PyObject_Vectorcall(r79, r81, 1, 0) + dec_ref r79 + if is_error(r82) goto L54 (error at :48) else goto L30 L30: - return r35 + dec_ref r76 + r83 = '__new__' + r84 = CPyDict_SetItem(r73, r83, r82) + dec_ref r82 + r85 = r84 >= 0 :: signed + if not r85 goto L53 (error at :48) else goto L31 :: bool L31: - r36 = :: bytes - return r36 + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 L32: - dec_ref non_prefixed_hex - goto L31 + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool L33: - dec_ref padded_hex - goto L13 + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 L34: - dec_ref padded_hex - goto L23 + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool L35: - dec_ref padded_hex - goto L21 + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) else goto L36 L36: - dec_ref r22 - goto L23 + r95 = 'to_0x_hex' + r96 = CPyDict_SetItem(r73, r95, r94) + dec_ref r94 + r97 = r96 >= 0 :: signed + if not r97 goto L53 (error at :75) else goto L37 :: bool L37: - dec_ref r15 - goto L20 + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 L38: - dec_ref r15 - goto L22 + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) else goto L39 :: bool L39: - dec_ref r14 - goto L26 + r102 = 'HexBytes' + r103 = '__annotations__' + r104 = CPyDict_SetItem(r73, r103, r75) + dec_ref r75 + r105 = r104 >= 0 :: signed + if not r105 goto L52 (error at :37) else goto L40 :: bool 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: + r106 = 'mypyc filler docstring' + r107 = '__doc__' + r108 = CPyDict_SetItem(r73, r107, r106) + r109 = r108 >= 0 :: signed + if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type return 1 -L8: - r26 = :: None - return r26 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 From d7cfb56527f2fec222425c4c7148c5a45d0165d9 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 02:25:24 -0400 Subject: [PATCH 30/70] Update setup.py --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 11d4714..121043c 100644 --- a/setup.py +++ b/setup.py @@ -68,7 +68,7 @@ license="MIT", zip_safe=False, keywords="ethereum", - packages=find_packages(exclude=["scripts", "scripts.*", "tests", "tests.*"]), + packages=find_packages(exclude=["scripts", "scripts.*", "tests", "tests.*", "benchmarks", "benchmarks.*"]), ext_modules=ext_modules, package_data={"faster_hexbytes": ["py.typed"]}, classifiers=[ From 13ce430bf9a27a5cd8d61a7d4d653aedbabcb339 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 06:25:51 +0000 Subject: [PATCH 31/70] chore: compile C files for source control --- build/ops.txt | 2290 ++++++++++++++++++++++++------------------------- 1 file changed, 1145 insertions(+), 1145 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 5ed32ca..a8ead04 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -101,644 +101,326 @@ 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 +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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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 :: 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 + 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 = PyBytes_Check(val) - if r0 goto L1 else goto L3 :: bool + 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__:63) else goto L1 L1: - inc_ref val - r1 = cast(bytes, val) - if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 L2: - return r1 + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool L3: - r2 = PyUnicode_Check(val) - if r2 goto L4 else goto L7 :: bool + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 L4: - inc_ref val - r3 = cast(str, val) - if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 + r8 = box(int, r7) + return r8 L5: - r4 = hexstr_to_bytes(r3) - dec_ref r3 - if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool L6: - return r4 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - r5 = PyByteArray_Check(val) - if r5 goto L8 else goto L11 :: bool + 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__:69) else goto L8 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 + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 L9: - r10 = cast(bytes, r9) - if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 + return r17 L10: - return r10 + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 L11: - r11 = PyBool_Check(val) - if r11 goto L12 else goto L17 :: bool + 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__:70) else goto L12 L12: - r12 = unbox(bool, val) - if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 L13: - if r12 goto L14 else goto L15 :: bool + return r22 L14: - r13 = b'\x01' - inc_ref r13 - r14 = r13 - goto L16 -L15: - r15 = b'\x00' - inc_ref r15 - r14 = r15 + r23 = :: union[int, faster_hexbytes.main.HexBytes] + return r23 +L15: + dec_ref r9 + goto L6 L16: - return r14 + dec_ref r12 + goto L14 L17: - r16 = PyLong_Check(val) - if r16 goto L18 else goto L37 :: bool + dec_ref r9 + goto L14 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 + dec_ref r18 + goto L14 -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 +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - if r4 goto L2 else goto L5 :: bool + inc_ref __mypyc_self__ + return __mypyc_self__ 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 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 +L3: + return r2 L4: - non_prefixed_hex = r6 - goto L6 + 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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:73) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:73) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) + dec_ref r8 + if is_error(r9) goto L8 (error at __repr__:73) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] + r13 = load_address r12 + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:73) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:73) else goto L5 L5: - inc_ref hexstr - non_prefixed_hex = hexstr + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:73) else goto L6 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 + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:73) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + return r22 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + r23 = :: str + return r23 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 + dec_ref r9 + goto L8 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 + goto L8 -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 +def to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L8 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 - -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 + 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 +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 = to_bytes(val) - if is_error(r0) goto L7 (error at __new__:49) else goto L1 + 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:79) else goto L1 L1: - r1 = faster_hexbytes.main._bytes_new :: static - if is_error(r1) goto L8 else goto L4 + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 L2: - r2 = raise NameError('value for final name "_bytes_new" was not set') - if not r2 goto L7 (error at __new__:50) else goto L3 :: bool + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) else goto L3 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) else goto L6 -L6: return r6 -L7: - r7 = :: faster_hexbytes.main.HexBytes +L4: + r7 = :: str return r7 -L8: - dec_ref r0 - goto L2 -L9: - dec_ref r0 - goto L7 -def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): +def __reduce___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit r2, r3 :: object @@ -758,317 +440,61 @@ L4: r3 = :: object return r3 -def __getitem___HexBytes_obj.__call__(__mypyc_self__, self, key): - __mypyc_self__ :: faster_hexbytes.main.__getitem___HexBytes_obj +def __reduce___HexBytes_obj.__call__(__mypyc_self__, self): + __mypyc_self__ :: faster_hexbytes.main.__reduce___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] + 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 = 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__:63) else goto L1 + r0 = faster_hexbytes.main._bytes_new :: static + if is_error(r0) goto L1 else goto L3 L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 + r1 = raise NameError('value for final name "_bytes_new" was not set') + if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool L2: - r6 = PyLong_Check(r5) - if r6 goto L3 else goto L5 :: bool + unreachable L3: - r7 = unbox(int, r5) - dec_ref r5 - if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 + 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__:89) else goto L4 L4: - r8 = box(int, r7) - return r8 + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 L5: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + r8 = (r2, r7) + inc_ref r0 + r9 = (r0, r8) + return r9 L6: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + r10 = :: tuple[object, tuple[object, bytes]] + return r10 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__:69) else goto L8 -L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 -L9: - return r17 -L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 -L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 -L13: - return r22 -L14: - r23 = :: union[int, faster_hexbytes.main.HexBytes] - return r23 -L15: - dec_ref r9 + dec_ref r2 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, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str -L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:73) else goto L1 -L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:73) else goto L2 -L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:73) else goto L3 -L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:73) else goto L4 -L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:73) else goto L5 -L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:73) else goto L6 -L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:73) else goto L7 -L7: - return r22 -L8: - r23 = :: str - return r23 -L9: - dec_ref r9 - goto L8 -L10: - dec_ref r15 - goto L8 - -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:79) else goto L1 -L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 -L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) 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__:89) 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__:89) else goto L4 -L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) 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 +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 @@ -1170,297 +596,871 @@ def __top_level__(): r132 :: object r133 :: None L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + 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 L48 (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 L48 (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 L48 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 L48 (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 L48 (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 L48 (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 L48 (error at :31) 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 L49 (error at :31) else goto L11 +L11: + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) 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 L48 (error at :31) 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 L48 (error at :31) else goto L14 :: bool +L14: + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) 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 L48 (error at :33) else goto L16 :: bool +L16: + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) else goto L17 +L17: + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) else goto L18 +L18: + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 +L22: + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 +L23: + r73 = r72 + goto L26 +L24: + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 +L25: + r73 = r74 +L26: + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 +L27: + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 +L28: + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool +L31: + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 +L32: + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool +L33: + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 +L34: + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool +L35: + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool +L37: + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 +L38: + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type + return 1 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 + +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: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L48 (error at :-1) else goto L2 + if r4 goto L2 else goto L5 :: bool L2: - builtins = r4 :: module - dec_ref r4 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 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 L48 (error at :1) else goto L4 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) 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 L48 else goto L5 :: bool + non_prefixed_hex = r6 + goto L6 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 L48 (error at :15) else goto L6 + inc_ref hexstr + non_prefixed_hex = hexstr 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 L48 (error at :18) else goto L7 + 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: - 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 L48 (error at :22) else goto L8 + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 L8: - faster_hexbytes._utils = r30 :: module - dec_ref r30 - if 0 goto L9 else goto L9 :: bool + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool L9: - r31 = faster_hexbytes.main.globals :: static - r32 = 'Union' - r33 = CPyDict_GetItem(r31, r32) - if is_error(r33) goto L48 (error at :31) else goto L10 + 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: - 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 L49 (error at :31) else goto L11 + padded_hex = r13 + goto L12 L11: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) else goto L12 + padded_hex = non_prefixed_hex 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 L48 (error at :31) else goto L13 + r14 = PyUnicode_AsASCIIString(padded_hex) + if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 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 L48 (error at :31) else goto L14 :: bool + goto L25 L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) else goto L15 + 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: - 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 L48 (error at :33) else goto L16 :: bool + r19 = CPy_ExceptionMatches(r18) + dec_ref r18 + if r19 goto L16 else goto L35 :: bool L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 + 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: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 + 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: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) else goto L19 + 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: - r64 = '__prepare__' - r65 = PyObject_HasAttr(r63, r64) - if r65 goto L20 else goto L24 :: bool + 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: - r66 = 'HexBytes' - r67 = '__prepare__' - r68 = CPyObject_GetAttr(r63, r67) - if is_error(r68) goto L51 (error at :37) 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 L51 (error at :37) else goto L22 + unreachable +L21: + CPy_Reraise() + if not 0 goto L23 else goto L38 :: bool L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 + unreachable L23: - r73 = r72 - goto L26 + CPy_RestoreExcInfo(r15) + dec_ref r15 + r29 = CPy_KeepPropagating() + if not r29 goto L31 else goto L24 :: bool L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 + unreachable L25: - r73 = r74 + r30 = faster_hexbytes._utils.unhexlify :: static + if is_error(r30) goto L39 else goto L28 L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 + 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: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 + unreachable L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) else goto L29 + 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: - r80 = [r76] - r81 = load_address r80 - r82 = PyObject_Vectorcall(r79, r81, 1, 0) - dec_ref r79 - if is_error(r82) goto L54 (error at :48) else goto L30 + dec_ref r14 + r35 = cast(bytes, r34) + if is_error(r35) goto L31 (error at hexstr_to_bytes:58) 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 L53 (error at :48) else goto L31 :: bool + return r35 L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 + r36 = :: bytes + return r36 L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool + dec_ref non_prefixed_hex + goto L31 L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 + dec_ref padded_hex + goto L13 L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool + dec_ref padded_hex + goto L23 L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) else goto L36 + dec_ref padded_hex + goto L21 L36: - r95 = 'to_0x_hex' - r96 = CPyDict_SetItem(r73, r95, r94) - dec_ref r94 - r97 = r96 >= 0 :: signed - if not r97 goto L53 (error at :75) else goto L37 :: bool + dec_ref r22 + goto L23 L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 + dec_ref r15 + goto L20 L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) else goto L39 :: bool + dec_ref r15 + goto L22 L39: - r102 = 'HexBytes' - r103 = '__annotations__' - r104 = CPyDict_SetItem(r73, r103, r75) - dec_ref r75 - r105 = r104 >= 0 :: signed - if not r105 goto L52 (error at :37) else goto L40 :: bool + dec_ref r14 + goto L26 L40: - r106 = 'mypyc filler docstring' - r107 = '__doc__' - r108 = CPyDict_SetItem(r73, r107, r106) - r109 = r108 >= 0 :: signed - if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type + 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 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 +L8: + r26 = :: None + return r26 From cbdcc533d3d74a4d0b6cc3df4a11090839910dc4 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 02:26:36 -0400 Subject: [PATCH 32/70] Update benchmark.yaml --- .github/workflows/benchmark.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/benchmark.yaml b/.github/workflows/benchmark.yaml index 50a0b8e..ba11d9d 100644 --- a/.github/workflows/benchmark.yaml +++ b/.github/workflows/benchmark.yaml @@ -26,6 +26,8 @@ jobs: python -m pip install --upgrade pip pip install .[dev] pip install pytest-codspeed pytest-benchmark hexbytes + - 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 From 735b8d27a51f52a09417f49b2d316d25cfa8e57e Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 02:27:05 -0400 Subject: [PATCH 33/70] Update codspeed.yaml --- .github/workflows/codspeed.yaml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/codspeed.yaml b/.github/workflows/codspeed.yaml index 505921c..6448073 100644 --- a/.github/workflows/codspeed.yaml +++ b/.github/workflows/codspeed.yaml @@ -24,8 +24,9 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install .[dev] - pip install pytest-codspeed hexbytes + 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: From 020f06daad2b08793ebe18de402668b1bb32ed9f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 06:27:31 +0000 Subject: [PATCH 34/70] chore: compile C files for source control --- build/ops.txt | 2458 ++++++++++++++++++++++++------------------------- 1 file changed, 1229 insertions(+), 1229 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index a8ead04..5ed32ca 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -101,326 +101,644 @@ L12: r34 = :: None return r34 -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__:49) 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__:50) 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) 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 +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 :: 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] + 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 = 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__:63) else goto L1 + r0 = PyBytes_Check(val) + if r0 goto L1 else goto L3 :: bool L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 + inc_ref val + r1 = cast(bytes, val) + if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 L2: - r6 = PyLong_Check(r5) - if r6 goto L3 else goto L5 :: bool + return r1 L3: - r7 = unbox(int, r5) - dec_ref r5 - if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 + r2 = PyUnicode_Check(val) + if r2 goto L4 else goto L7 :: bool L4: - r8 = box(int, r7) - return r8 + inc_ref val + r3 = cast(str, val) + if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 L5: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + r4 = hexstr_to_bytes(r3) + dec_ref r3 + if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 L6: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + return r4 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__:69) else goto L8 + r5 = PyByteArray_Check(val) + if r5 goto L8 else goto L11 :: bool L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 + 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: - return r17 + r10 = cast(bytes, r9) + if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 + return r10 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__:70) else goto L12 + r11 = PyBool_Check(val) + if r11 goto L12 else goto L17 :: bool L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 + r12 = unbox(bool, val) + if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 L13: - return r22 + if r12 goto L14 else goto L15 :: bool L14: - r23 = :: union[int, faster_hexbytes.main.HexBytes] - return r23 -L15: - dec_ref r9 - goto L6 + r13 = b'\x01' + inc_ref r13 + r14 = r13 + goto L16 +L15: + r15 = b'\x00' + inc_ref r15 + r14 = r15 L16: - dec_ref r12 - goto L14 + return r14 L17: - dec_ref r9 - goto L14 + r16 = PyLong_Check(val) + if r16 goto L18 else goto L37 :: bool L18: - dec_ref r18 - goto L14 + 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 __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + 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: - inc_ref __mypyc_self__ - return __mypyc_self__ + if r4 goto L2 else goto L5 :: bool 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, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str -L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:73) else goto L1 -L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:73) else goto L2 -L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:73) else goto L3 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:73) else goto L4 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:73) else goto L5 + non_prefixed_hex = r6 + goto L6 L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:73) else goto L6 + inc_ref hexstr + non_prefixed_hex = hexstr L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:73) else goto L7 + 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: - return r22 + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 L8: - r23 = :: str - return r23 + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool L9: - dec_ref r9 - goto L8 + 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 - goto L8 + 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 to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - inc_ref __mypyc_self__ - return __mypyc_self__ + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L8 (error at :-1) else goto L2 L2: - r2 = PyMethod_New(__mypyc_self__, instance) - if is_error(r2) goto L4 else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - return r2 + 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: - 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 + 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 + +def __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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:79) else goto L1 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) else goto L3 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 L3: - return r6 + return r2 L4: - r7 = :: str + 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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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 __reduce___HexBytes_obj.__get__(__mypyc_self__, instance, owner): +def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit r2, r3 :: object @@ -440,1027 +758,709 @@ L4: r3 = :: object return r3 -def __reduce___HexBytes_obj.__call__(__mypyc_self__, self): - __mypyc_self__ :: faster_hexbytes.main.__reduce___HexBytes_obj +def __getitem___HexBytes_obj.__call__(__mypyc_self__, self, key): + __mypyc_self__ :: faster_hexbytes.main.__getitem___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]] + 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 = faster_hexbytes.main._bytes_new :: static - if is_error(r0) goto L1 else goto L3 + 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__:63) else goto L1 L1: - r1 = raise NameError('value for final name "_bytes_new" was not set') - if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 L2: - unreachable + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool 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__:89) else goto L4 + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 + r8 = box(int, r7) + return r8 L5: - r8 = (r2, r7) - inc_ref r0 - r9 = (r0, r8) - return r9 + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool L6: - r10 = :: tuple[object, tuple[object, bytes]] - return r10 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - dec_ref r2 + 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__:69) else goto L8 +L8: + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 +L9: + return r17 +L10: + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 +L12: + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) 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 __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 :: object - r121 :: object[1] - r122 :: object_ptr - r123, r124 :: object - r125 :: object[1] - r126 :: object_ptr - r127 :: object - r128 :: dict - r129 :: str - r130 :: i32 - r131 :: bit - r132 :: object - r133 :: None +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L48 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 L48 (error at :1) else goto L4 + return r2 L4: - typing = r8 :: module + 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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:73) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:73) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) dec_ref r8 - r9 = load_address hexbytes.main :: module - r10 = [r9] - r11 = load_address r10 - r12 = [14] + if is_error(r9) goto L8 (error at __repr__:73) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] 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 L48 else goto L5 :: bool + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:73) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:73) else goto L5 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 L48 (error at :15) else goto L6 + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:73) 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 L48 (error at :18) else goto L7 + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:73) 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 L48 (error at :22) else goto L8 + return r22 L8: - faster_hexbytes._utils = r30 :: module - dec_ref r30 - if 0 goto L9 else goto L9 :: bool + r23 = :: str + return r23 L9: - r31 = faster_hexbytes.main.globals :: static - r32 = 'Union' - r33 = CPyDict_GetItem(r31, r32) - if is_error(r33) goto L48 (error at :31) else goto L10 + dec_ref r9 + goto L8 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 L49 (error at :31) else goto L11 -L11: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) 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 L48 (error at :31) 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 L48 (error at :31) else goto L14 :: bool -L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) 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 L48 (error at :33) else goto L16 :: bool -L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 -L17: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 -L18: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 -L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 -L23: - r73 = r72 - goto L26 -L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 -L25: - r73 = r74 -L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 -L27: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 -L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool -L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 -L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool -L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 -L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool -L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool -L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 -L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type - return 1 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 - -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: + dec_ref r15 + goto L8 + +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:79) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 +L2: + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) 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__:89) else goto L2 :: bool +L2: 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 +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__:89) else goto L4 +L4: + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) 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 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 +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 :: object - r26 :: object[1] - r27 :: object_ptr - r28 :: object - r29 :: bit + r25 :: dict + r26, r27 :: object + r28 :: str + r29 :: dict r30 :: object - r31 :: bool - r32 :: object[1] - r33 :: object_ptr - r34 :: object - r35, r36 :: bytes + 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 :: object + r121 :: object[1] + r122 :: object_ptr + r123, r124 :: object + r125 :: object[1] + r126 :: object_ptr + r127 :: object + r128 :: dict + r129 :: str + r130 :: i32 + r131 :: bit + r132 :: object + r133 :: None 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 + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - if r4 goto L2 else goto L5 :: bool + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L48 (error at :-1) else goto L2 L2: - r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) - if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - r6 = cast(str, r5) - if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 + 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 L48 (error at :1) else goto L4 L4: - non_prefixed_hex = r6 - goto L6 + 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 L48 else goto L5 :: bool L5: - inc_ref hexstr - non_prefixed_hex = hexstr + r19 = ('mypyc_attr',) + r20 = 'mypy_extensions' + r21 = faster_hexbytes.main.globals :: static + r22 = CPyImport_ImportFromMany(r20, r19, r19, r21) + if is_error(r22) goto L48 (error at :15) else goto L6 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 + 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 L48 (error at :18) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + 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 L48 (error at :22) else goto L8 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + faster_hexbytes._utils = r30 :: module + dec_ref r30 + if 0 goto L9 else goto L9 :: 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 + r31 = faster_hexbytes.main.globals :: static + r32 = 'Union' + r33 = CPyDict_GetItem(r31, r32) + if is_error(r33) goto L48 (error at :31) else goto L10 L10: - padded_hex = r13 - goto L12 + 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 L49 (error at :31) else goto L11 L11: - padded_hex = non_prefixed_hex + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) else goto L12 L12: - r14 = PyUnicode_AsASCIIString(padded_hex) - if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 + 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 L48 (error at :31) else goto L13 L13: - goto L25 + 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 L48 (error at :31) else goto L14 :: bool 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 + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) else goto L15 L15: - r19 = CPy_ExceptionMatches(r18) - dec_ref r18 - if r19 goto L16 else goto L35 :: bool + 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 L48 (error at :33) else goto L16 :: 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 + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) 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 + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) 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 + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 + r64 = '__prepare__' + r65 = PyObject_HasAttr(r63, r64) + if r65 goto L20 else goto L24 :: bool L20: - unreachable + r66 = 'HexBytes' + r67 = '__prepare__' + r68 = CPyObject_GetAttr(r63, r67) + if is_error(r68) goto L51 (error at :37) else goto L21 L21: - CPy_Reraise() - if not 0 goto L23 else goto L38 :: bool + r69 = [r66, r61] + r70 = load_address r69 + r71 = PyObject_Vectorcall(r68, r70, 2, 0) + dec_ref r68 + if is_error(r71) goto L51 (error at :37) else goto L22 L22: - unreachable + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 L23: - CPy_RestoreExcInfo(r15) - dec_ref r15 - r29 = CPy_KeepPropagating() - if not r29 goto L31 else goto L24 :: bool + r73 = r72 + goto L26 L24: - unreachable + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 L25: - r30 = faster_hexbytes._utils.unhexlify :: static - if is_error(r30) goto L39 else goto L28 + r73 = r74 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 + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 L27: - unreachable + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 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 + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 + r80 = [r76] + r81 = load_address r80 + r82 = PyObject_Vectorcall(r79, r81, 1, 0) + dec_ref r79 + if is_error(r82) goto L54 (error at :48) else goto L30 L30: - return r35 + dec_ref r76 + r83 = '__new__' + r84 = CPyDict_SetItem(r73, r83, r82) + dec_ref r82 + r85 = r84 >= 0 :: signed + if not r85 goto L53 (error at :48) else goto L31 :: bool L31: - r36 = :: bytes - return r36 + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 L32: - dec_ref non_prefixed_hex - goto L31 + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool L33: - dec_ref padded_hex - goto L13 + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 L34: - dec_ref padded_hex - goto L23 + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool L35: - dec_ref padded_hex - goto L21 + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) else goto L36 L36: - dec_ref r22 - goto L23 + r95 = 'to_0x_hex' + r96 = CPyDict_SetItem(r73, r95, r94) + dec_ref r94 + r97 = r96 >= 0 :: signed + if not r97 goto L53 (error at :75) else goto L37 :: bool L37: - dec_ref r15 - goto L20 + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 L38: - dec_ref r15 - goto L22 + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) else goto L39 :: bool L39: - dec_ref r14 - goto L26 + r102 = 'HexBytes' + r103 = '__annotations__' + r104 = CPyDict_SetItem(r73, r103, r75) + dec_ref r75 + r105 = r104 >= 0 :: signed + if not r105 goto L52 (error at :37) else goto L40 :: bool 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: + r106 = 'mypyc filler docstring' + r107 = '__doc__' + r108 = CPyDict_SetItem(r73, r107, r106) + r109 = r108 >= 0 :: signed + if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type return 1 -L8: - r26 = :: None - return r26 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 From 2dac80860c097e50803e37d1f30e5afd87bfc571 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 02:27:35 -0400 Subject: [PATCH 35/70] Update benchmark.yaml --- .github/workflows/benchmark.yaml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/benchmark.yaml b/.github/workflows/benchmark.yaml index ba11d9d..33b4ce8 100644 --- a/.github/workflows/benchmark.yaml +++ b/.github/workflows/benchmark.yaml @@ -24,8 +24,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install .[dev] - pip install pytest-codspeed pytest-benchmark hexbytes + 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 From 398a213893570d50cc7893cd76fbde0f90536d37 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 06:27:59 +0000 Subject: [PATCH 36/70] chore: compile C files for source control --- build/ops.txt | 1664 ++++++++++++++++++++++++------------------------- 1 file changed, 832 insertions(+), 832 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 5ed32ca..936de4d 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,875 +1,198 @@ -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 +def __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L12 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 + return r2 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 + r3 = :: object + return r3 -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 +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 = PyBytes_Check(val) - if r0 goto L1 else goto L3 :: bool + r0 = to_bytes(val) + if is_error(r0) goto L7 (error at __new__:49) else goto L1 L1: - inc_ref val - r1 = cast(bytes, val) - if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 + r1 = faster_hexbytes.main._bytes_new :: static + if is_error(r1) goto L8 else goto L4 L2: - return r1 + r2 = raise NameError('value for final name "_bytes_new" was not set') + if not r2 goto L7 (error at __new__:50) else goto L3 :: bool L3: - r2 = PyUnicode_Check(val) - if r2 goto L4 else goto L7 :: bool + unreachable L4: - inc_ref val - r3 = cast(str, val) - if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 + r3 = [cls, r0] + r4 = load_address r3 + r5 = PyObject_Vectorcall(r1, r4, 2, 0) + if is_error(r5) goto L9 (error at __new__:50) 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 + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) else goto L6 L6: - return r4 + return r6 L7: - r5 = PyByteArray_Check(val) - if r5 goto L8 else goto L11 :: bool + r7 = :: faster_hexbytes.main.HexBytes + return r7 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 + dec_ref r0 + goto L2 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 + dec_ref r0 + goto L7 -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 +def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - if r4 goto L2 else goto L5 :: bool + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) - if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 L3: - r6 = cast(str, r5) - if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 + return r2 L4: - non_prefixed_hex = r6 - goto L6 -L5: - inc_ref hexstr - non_prefixed_hex = hexstr + 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__:63) else goto L1 +L1: + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) 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__:65) 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: - 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 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + 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__:69) else goto L8 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 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 + return r17 L10: - padded_hex = r13 - goto L12 + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 L11: - padded_hex = non_prefixed_hex + 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__:70) else goto L12 L12: - r14 = PyUnicode_AsASCIIString(padded_hex) - if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 L13: - goto L25 + return r22 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 + r23 = :: union[int, faster_hexbytes.main.HexBytes] + return r23 L15: - r19 = CPy_ExceptionMatches(r18) - dec_ref r18 - if r19 goto L16 else goto L35 :: bool + dec_ref r9 + goto L6 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 + dec_ref r12 + goto L14 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 + dec_ref r9 + goto L14 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 + dec_ref r18 + goto L14 -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 +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L8 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 - -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__:49) 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__:50) 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) 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__:63) else goto L1 -L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) 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__:65) 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__:69) 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__:69) else goto L8 -L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 -L9: - return r17 -L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 -L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) 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 + return r2 L4: r3 = :: object return r3 @@ -1464,3 +787,680 @@ L54: L55: dec_ref r116 goto L48 + +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 + +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 From 3373a250467a4de59c3a062e955465e2b3f1e4bf Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 02:35:32 -0400 Subject: [PATCH 37/70] fix broken benchmarks --- benchmarks/params.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/benchmarks/params.py b/benchmarks/params.py index 5dcf67c..1f65047 100644 --- a/benchmarks/params.py +++ b/benchmarks/params.py @@ -68,7 +68,6 @@ def variant_ids(base_ids: List[str], prefix: str) -> List[str]: ("0x" + "00" * 64, "'0x'+'00'*64"), ("0xabcdef", "'0xabcdef'"), ("0x" + "a" * 128, "'0x'+'a'*128"), - ("unicode-✓-测试", "unicode string"), ("0xdeadbeef", "'0xdeadbeef'"), ("0xCAFEBABE", "'0xCAFEBABE'"), ] @@ -78,7 +77,6 @@ def variant_ids(base_ids: List[str], prefix: str) -> List[str]: INT_CASES: List[Tuple[int, str]] = [ (123456, "123456"), (0, "0"), - (-1, "-1"), (2**8, "2**8"), (2**16, "2**16"), (2**32, "2**32"), From 6b828d47a5f574666ba14989df568edc19eb3a37 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 06:35:59 +0000 Subject: [PATCH 38/70] chore: compile C files for source control --- build/ops.txt | 206 +++++++++++++++++++++++++------------------------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 936de4d..5ed80ec 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -788,6 +788,109 @@ L55: dec_ref r116 goto L48 +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 @@ -1361,106 +1464,3 @@ L7: L8: r26 = :: None return r26 - -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 From 1ae7b824113dea3c5a11c9e0908223035a96b497 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 03:00:10 -0400 Subject: [PATCH 39/70] Update test__utils_benchmarks.py --- benchmarks/test__utils_benchmarks.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/benchmarks/test__utils_benchmarks.py b/benchmarks/test__utils_benchmarks.py index e40d538..d0a1c97 100644 --- a/benchmarks/test__utils_benchmarks.py +++ b/benchmarks/test__utils_benchmarks.py @@ -1,4 +1,4 @@ -from typing import Any +from typing import Any, Callable import hexbytes._utils import pytest @@ -11,22 +11,26 @@ 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(hexbytes._utils.to_bytes, val) + 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(faster_hexbytes._utils.to_bytes, val) + 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(hexbytes._utils.hexstr_to_bytes, hexstr) + 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(faster_hexbytes._utils.hexstr_to_bytes, hexstr) + benchmark(run_100, faster_hexbytes._utils.hexstr_to_bytes, hexstr) From 6a83b63ae1daecf5575eb35ac67d9fd123677149 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 07:00:39 +0000 Subject: [PATCH 40/70] chore: compile C files for source control --- build/ops.txt | 2546 ++++++++++++++++++++++++------------------------- 1 file changed, 1273 insertions(+), 1273 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 5ed80ec..d40a5c1 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,323 +1,641 @@ -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__:49) 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__:50) 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) 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 +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 :: 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] + 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 = 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__:63) else goto L1 + r0 = PyBytes_Check(val) + if r0 goto L1 else goto L3 :: bool L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 + inc_ref val + r1 = cast(bytes, val) + if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 L2: - r6 = PyLong_Check(r5) - if r6 goto L3 else goto L5 :: bool + return r1 L3: - r7 = unbox(int, r5) - dec_ref r5 - if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 + r2 = PyUnicode_Check(val) + if r2 goto L4 else goto L7 :: bool L4: - r8 = box(int, r7) - return r8 + inc_ref val + r3 = cast(str, val) + if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 L5: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + r4 = hexstr_to_bytes(r3) + dec_ref r3 + if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 L6: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + return r4 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__:69) else goto L8 + r5 = PyByteArray_Check(val) + if r5 goto L8 else goto L11 :: bool L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 + 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: - return r17 + r10 = cast(bytes, r9) + if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 + return r10 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__:70) else goto L12 + r11 = PyBool_Check(val) + if r11 goto L12 else goto L17 :: bool L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 + r12 = unbox(bool, val) + if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 L13: - return r22 + if r12 goto L14 else goto L15 :: bool L14: - r23 = :: union[int, faster_hexbytes.main.HexBytes] - return r23 -L15: - dec_ref r9 - goto L6 + r13 = b'\x01' + inc_ref r13 + r14 = r13 + goto L16 +L15: + r15 = b'\x00' + inc_ref r15 + r14 = r15 L16: - dec_ref r12 - goto L14 + return r14 L17: - dec_ref r9 - goto L14 + r16 = PyLong_Check(val) + if r16 goto L18 else goto L37 :: bool L18: - dec_ref r18 - goto L14 + 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 __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + 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: - inc_ref __mypyc_self__ - return __mypyc_self__ + if r4 goto L2 else goto L5 :: bool 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, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str -L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:73) else goto L1 -L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:73) else goto L2 -L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:73) else goto L3 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:73) else goto L4 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:73) else goto L5 + non_prefixed_hex = r6 + goto L6 L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:73) else goto L6 + inc_ref hexstr + non_prefixed_hex = hexstr L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:73) else goto L7 + 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: - return r22 + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 L8: - r23 = :: str - return r23 + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool L9: - dec_ref r9 - goto L8 + 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 - goto L8 + 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 to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - inc_ref __mypyc_self__ - return __mypyc_self__ + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L8 (error at :-1) else goto L2 L2: - r2 = PyMethod_New(__mypyc_self__, instance) - if is_error(r2) goto L4 else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - return r2 + 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: - 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 + 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 + +def __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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:79) else goto L1 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) else goto L3 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 L3: - return r6 + return r2 L4: - r7 = :: str + 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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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 __reduce___HexBytes_obj.__get__(__mypyc_self__, instance, owner): +def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit r2, r3 :: object @@ -337,88 +655,344 @@ L4: r3 = :: object return r3 -def __reduce___HexBytes_obj.__call__(__mypyc_self__, self): - __mypyc_self__ :: faster_hexbytes.main.__reduce___HexBytes_obj +def __getitem___HexBytes_obj.__call__(__mypyc_self__, self, key): + __mypyc_self__ :: faster_hexbytes.main.__getitem___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]] + 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 = faster_hexbytes.main._bytes_new :: static - if is_error(r0) goto L1 else goto L3 + 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__:63) else goto L1 L1: - r1 = raise NameError('value for final name "_bytes_new" was not set') - if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 L2: - unreachable + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool 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__:89) else goto L4 + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 + r8 = box(int, r7) + return r8 L5: - r8 = (r2, r7) - inc_ref r0 - r9 = (r0, r8) - return r9 + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool L6: - r10 = :: tuple[object, tuple[object, bytes]] - return r10 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - dec_ref r2 + 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__:69) else goto L8 +L8: + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 +L9: + return r17 +L10: + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 +L12: + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) 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 __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 +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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:73) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:73) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) + dec_ref r8 + if is_error(r9) goto L8 (error at __repr__:73) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] + r13 = load_address r12 + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:73) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:73) else goto L5 +L5: + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:73) else goto L6 +L6: + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:73) else goto L7 +L7: + return r22 +L8: + r23 = :: str + return r23 +L9: + dec_ref r9 + goto L8 +L10: + dec_ref r15 + goto L8 + +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:79) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 +L2: + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) 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__:89) 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__:89) else goto L4 +L4: + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) 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 @@ -474,946 +1048,351 @@ def __top_level__(): r110, r111 :: str r112 :: i32 r113 :: bit - r114 :: object[3] - r115 :: object_ptr - r116 :: object - r117 :: dict - r118 :: str - r119, r120 :: object - r121 :: object[1] - r122 :: object_ptr - r123, r124 :: object - r125 :: object[1] - r126 :: object_ptr - r127 :: object - r128 :: dict - r129 :: str - r130 :: i32 - r131 :: bit - r132 :: object - r133 :: 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 L48 (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 L48 (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 L48 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 L48 (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 L48 (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 L48 (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 L48 (error at :31) 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 L49 (error at :31) else goto L11 -L11: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) 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 L48 (error at :31) 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 L48 (error at :31) else goto L14 :: bool -L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) 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 L48 (error at :33) else goto L16 :: bool -L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 -L17: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 -L18: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 -L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 -L23: - r73 = r72 - goto L26 -L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 -L25: - r73 = r74 -L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 -L27: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 -L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool -L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 -L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool -L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 -L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool -L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool -L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 -L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type - return 1 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 - -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 + r114 :: object[3] + r115 :: object_ptr + r116 :: object + r117 :: dict + r118 :: str + r119, r120 :: object + r121 :: object[1] + r122 :: object_ptr + r123, r124 :: object + r125 :: object[1] + r126 :: object_ptr + r127 :: object + r128 :: dict + r129 :: str + r130 :: i32 + r131 :: bit + r132 :: object + r133 :: None 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 + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - if r4 goto L2 else goto L5 :: bool + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L48 (error at :-1) else goto L2 L2: - r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) - if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - r6 = cast(str, r5) - if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 + 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 L48 (error at :1) else goto L4 L4: - non_prefixed_hex = r6 - goto L6 + 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 L48 else goto L5 :: bool L5: - inc_ref hexstr - non_prefixed_hex = hexstr + r19 = ('mypyc_attr',) + r20 = 'mypy_extensions' + r21 = faster_hexbytes.main.globals :: static + r22 = CPyImport_ImportFromMany(r20, r19, r19, r21) + if is_error(r22) goto L48 (error at :15) else goto L6 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 + 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 L48 (error at :18) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + 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 L48 (error at :22) else goto L8 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + faster_hexbytes._utils = r30 :: module + dec_ref r30 + if 0 goto L9 else goto L9 :: 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 + r31 = faster_hexbytes.main.globals :: static + r32 = 'Union' + r33 = CPyDict_GetItem(r31, r32) + if is_error(r33) goto L48 (error at :31) else goto L10 L10: - padded_hex = r13 - goto L12 + 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 L49 (error at :31) else goto L11 L11: - padded_hex = non_prefixed_hex + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) else goto L12 L12: - r14 = PyUnicode_AsASCIIString(padded_hex) - if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 + 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 L48 (error at :31) else goto L13 L13: - goto L25 + 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 L48 (error at :31) else goto L14 :: bool 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 + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) else goto L15 L15: - r19 = CPy_ExceptionMatches(r18) - dec_ref r18 - if r19 goto L16 else goto L35 :: bool + 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 L48 (error at :33) else goto L16 :: 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 + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) 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 + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) 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 + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 + r64 = '__prepare__' + r65 = PyObject_HasAttr(r63, r64) + if r65 goto L20 else goto L24 :: bool L20: - unreachable + r66 = 'HexBytes' + r67 = '__prepare__' + r68 = CPyObject_GetAttr(r63, r67) + if is_error(r68) goto L51 (error at :37) else goto L21 L21: - CPy_Reraise() - if not 0 goto L23 else goto L38 :: bool + r69 = [r66, r61] + r70 = load_address r69 + r71 = PyObject_Vectorcall(r68, r70, 2, 0) + dec_ref r68 + if is_error(r71) goto L51 (error at :37) else goto L22 L22: - unreachable + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 L23: - CPy_RestoreExcInfo(r15) - dec_ref r15 - r29 = CPy_KeepPropagating() - if not r29 goto L31 else goto L24 :: bool + r73 = r72 + goto L26 L24: - unreachable + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 L25: - r30 = faster_hexbytes._utils.unhexlify :: static - if is_error(r30) goto L39 else goto L28 + r73 = r74 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 + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 L27: - unreachable + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 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 + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 + r80 = [r76] + r81 = load_address r80 + r82 = PyObject_Vectorcall(r79, r81, 1, 0) + dec_ref r79 + if is_error(r82) goto L54 (error at :48) else goto L30 L30: - return r35 + dec_ref r76 + r83 = '__new__' + r84 = CPyDict_SetItem(r73, r83, r82) + dec_ref r82 + r85 = r84 >= 0 :: signed + if not r85 goto L53 (error at :48) else goto L31 :: bool L31: - r36 = :: bytes - return r36 + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 L32: - dec_ref non_prefixed_hex - goto L31 + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool L33: - dec_ref padded_hex - goto L13 + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 L34: - dec_ref padded_hex - goto L23 + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool L35: - dec_ref padded_hex - goto L21 + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) else goto L36 L36: - dec_ref r22 - goto L23 + r95 = 'to_0x_hex' + r96 = CPyDict_SetItem(r73, r95, r94) + dec_ref r94 + r97 = r96 >= 0 :: signed + if not r97 goto L53 (error at :75) else goto L37 :: bool L37: - dec_ref r15 - goto L20 + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 L38: - dec_ref r15 - goto L22 + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) else goto L39 :: bool L39: - dec_ref r14 - goto L26 + r102 = 'HexBytes' + r103 = '__annotations__' + r104 = CPyDict_SetItem(r73, r103, r75) + dec_ref r75 + r105 = r104 >= 0 :: signed + if not r105 goto L52 (error at :37) else goto L40 :: bool L40: - dec_ref r14 - goto L31 + r106 = 'mypyc filler docstring' + r107 = '__doc__' + r108 = CPyDict_SetItem(r73, r107, r106) + r109 = r108 >= 0 :: signed + if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type + return 1 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 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 + 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 @@ -1422,45 +1401,66 @@ L0: L1: r3 = 'builtins' r4 = PyImport_Import(r3) - if is_error(r4) goto L8 (error at :-1) else goto L2 + if is_error(r4) goto L12 (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 + 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: - 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 + 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: - 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 + 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: - 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 + 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: - return 1 + 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 = :: None - return r26 + 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 From 8a92df1eaaff4425fc2af71466bb292595468fa3 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 03:01:51 -0400 Subject: [PATCH 41/70] Update test_main_benchmarks.py --- benchmarks/test_main_benchmarks.py | 26 +++++++++++++++----------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/benchmarks/test_main_benchmarks.py b/benchmarks/test_main_benchmarks.py index 2a7d217..49a1d84 100644 --- a/benchmarks/test_main_benchmarks.py +++ b/benchmarks/test_main_benchmarks.py @@ -1,4 +1,4 @@ -from typing import Any +from typing import Any, Callable import hexbytes import pytest @@ -11,15 +11,19 @@ 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(hexbytes.HexBytes, val) + 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(faster_hexbytes.HexBytes, val) + benchmark(run_100, faster_hexbytes.HexBytes, val) @pytest.mark.benchmark(group="HexBytes.__getitem__ (index)") @pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) @@ -27,7 +31,7 @@ def test_faster_hexbytes_new(benchmark: BenchmarkFixture, val: Any) -> None: def test_hexbytes_getitem_index(benchmark: BenchmarkFixture, val: bytes, idx: int) -> None: obj = hexbytes.HexBytes(val) if len(val) <= abs(idx): - benchmark(lambda: obj[idx]) + benchmark(run_100, lambda: obj[idx]) @pytest.mark.benchmark(group="HexBytes.__getitem__ (index)") @pytest.mark.parametrize("val", BYTES_VALS, ids=BYTES_IDS) @@ -35,42 +39,42 @@ def test_hexbytes_getitem_index(benchmark: BenchmarkFixture, val: bytes, idx: in def test_faster_hexbytes_getitem_index(benchmark: BenchmarkFixture, val: bytes, idx: int) -> None: obj = faster_hexbytes.HexBytes(val) if len(val) > abs(idx): - benchmark(lambda: obj[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(lambda: obj[slice_]) + 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(lambda: obj[slice_]) + 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(obj.__repr__) + 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(obj.__repr__) + 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(obj.to_0x_hex) + 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(obj.to_0x_hex) + benchmark(run_100, obj.to_0x_hex) From c500ced72dcf542103bb1600829aaacc456aef2e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 07:02:12 +0000 Subject: [PATCH 42/70] chore: compile C files for source control --- build/ops.txt | 206 +++++++++++++++++++++++++------------------------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index d40a5c1..5ed32ca 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,3 +1,106 @@ +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 @@ -1361,106 +1464,3 @@ L54: L55: dec_ref r116 goto L48 - -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 From ffe0636f1916b6ac8c3dd4f0d212e5c9c2fd9b5d Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 03:26:36 -0400 Subject: [PATCH 43/70] Update test_main_benchmarks.py --- benchmarks/test_main_benchmarks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmarks/test_main_benchmarks.py b/benchmarks/test_main_benchmarks.py index 49a1d84..43143f4 100644 --- a/benchmarks/test_main_benchmarks.py +++ b/benchmarks/test_main_benchmarks.py @@ -30,7 +30,7 @@ def test_faster_hexbytes_new(benchmark: BenchmarkFixture, val: Any) -> None: @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): + if len(val) > abs(idx): benchmark(run_100, lambda: obj[idx]) @pytest.mark.benchmark(group="HexBytes.__getitem__ (index)") From 288dcd0f19fee79b3ad137dac85f8442ae12e4dc Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 07:26:59 +0000 Subject: [PATCH 44/70] chore: compile C files for source control --- build/ops.txt | 1664 ++++++++++++++++++++++++------------------------- 1 file changed, 832 insertions(+), 832 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 5ed32ca..936de4d 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,875 +1,198 @@ -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 +def __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L12 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 + return r2 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 + r3 = :: object + return r3 -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 +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 = PyBytes_Check(val) - if r0 goto L1 else goto L3 :: bool + r0 = to_bytes(val) + if is_error(r0) goto L7 (error at __new__:49) else goto L1 L1: - inc_ref val - r1 = cast(bytes, val) - if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 + r1 = faster_hexbytes.main._bytes_new :: static + if is_error(r1) goto L8 else goto L4 L2: - return r1 + r2 = raise NameError('value for final name "_bytes_new" was not set') + if not r2 goto L7 (error at __new__:50) else goto L3 :: bool L3: - r2 = PyUnicode_Check(val) - if r2 goto L4 else goto L7 :: bool + unreachable L4: - inc_ref val - r3 = cast(str, val) - if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 + r3 = [cls, r0] + r4 = load_address r3 + r5 = PyObject_Vectorcall(r1, r4, 2, 0) + if is_error(r5) goto L9 (error at __new__:50) 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 + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) else goto L6 L6: - return r4 + return r6 L7: - r5 = PyByteArray_Check(val) - if r5 goto L8 else goto L11 :: bool + r7 = :: faster_hexbytes.main.HexBytes + return r7 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 + dec_ref r0 + goto L2 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 + dec_ref r0 + goto L7 -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 +def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - if r4 goto L2 else goto L5 :: bool + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) - if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 L3: - r6 = cast(str, r5) - if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 + return r2 L4: - non_prefixed_hex = r6 - goto L6 -L5: - inc_ref hexstr - non_prefixed_hex = hexstr + 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__:63) else goto L1 +L1: + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) 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__:65) 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: - 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 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + 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__:69) else goto L8 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 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 + return r17 L10: - padded_hex = r13 - goto L12 + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 L11: - padded_hex = non_prefixed_hex + 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__:70) else goto L12 L12: - r14 = PyUnicode_AsASCIIString(padded_hex) - if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 L13: - goto L25 + return r22 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 + r23 = :: union[int, faster_hexbytes.main.HexBytes] + return r23 L15: - r19 = CPy_ExceptionMatches(r18) - dec_ref r18 - if r19 goto L16 else goto L35 :: bool + dec_ref r9 + goto L6 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 + dec_ref r12 + goto L14 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 + dec_ref r9 + goto L14 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 + dec_ref r18 + goto L14 -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 +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L8 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 - -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__:49) 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__:50) 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) 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__:63) else goto L1 -L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) 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__:65) 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__:69) 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__:69) else goto L8 -L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 -L9: - return r17 -L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 -L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) 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 + return r2 L4: r3 = :: object return r3 @@ -1464,3 +787,680 @@ L54: L55: dec_ref r116 goto L48 + +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 + +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 From 76c03d9401624216aeef4c4f092bd3906ffb6fe6 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 05:06:28 -0400 Subject: [PATCH 45/70] run comparison benchmarks (#2) * run comparison benchmarks * Update benchmark results [skip ci] --------- Co-authored-by: github-actions[bot] --- benchmarks/results/_utils.md | 141 ++++++++++ benchmarks/results/main.md | 486 +++++++++++++++++++++++++++++++++++ 2 files changed, 627 insertions(+) create mode 100644 benchmarks/results/_utils.md create mode 100644 benchmarks/results/main.md diff --git a/benchmarks/results/_utils.md b/benchmarks/results/_utils.md new file mode 100644 index 0000000..cddf5a2 --- /dev/null +++ b/benchmarks/results/_utils.md @@ -0,0 +1,141 @@ +#### [faster_hexbytes._utils](https://github.com/BobTheBuidler/faster-hexbytes/blob/benchmark/faster_hexbytes/_utils.py) - [view benchmarks](https://github.com/BobTheBuidler/faster-hexbytes/blob/benchmark/benchmarks/test__utils_benchmarks.py) + +| Function | Reference Mean | Faster Mean | % Change | Speedup (%) | x Faster | Faster | +|----------|---------------|-------------|----------|-------------|----------|--------| +| `hexstr_to_bytes['']` | 1.7693315307804868e-05 | 1.1179726147479144e-05 | 36.81% | 58.26% | 1.58x | ✅ | +| `hexstr_to_bytes['0x'+'0'*128]` | 3.42949906090721e-05 | 2.098034489856244e-05 | 38.82% | 63.46% | 1.63x | ✅ | +| `hexstr_to_bytes['0x'+'00'*64]` | 3.4029689635560134e-05 | 2.10303706868544e-05 | 38.20% | 61.81% | 1.62x | ✅ | +| `hexstr_to_bytes['0x'+'00ff'*16]` | 3.094838328028653e-05 | 1.807462000181124e-05 | 41.60% | 71.23% | 1.71x | ✅ | +| `hexstr_to_bytes['0x'+'0123456789abcdef'*8]` | 3.432770530738586e-05 | 2.0939726654757956e-05 | 39.00% | 63.94% | 1.64x | ✅ | +| `hexstr_to_bytes['0x'+'1'*64]` | 3.106500558142552e-05 | 1.803506739850267e-05 | 41.94% | 72.25% | 1.72x | ✅ | +| `hexstr_to_bytes['0x'+'1234567890abcdef'*8]` | 3.444213332083847e-05 | 2.1062415055709138e-05 | 38.85% | 63.52% | 1.64x | ✅ | +| `hexstr_to_bytes['0x'+'a'*128]` | 3.402123802839552e-05 | 2.1096504577780626e-05 | 37.99% | 61.26% | 1.61x | ✅ | +| `hexstr_to_bytes['0x'+'a1b2c3d4'*8]` | 3.118321973125747e-05 | 1.865736666332591e-05 | 40.17% | 67.14% | 1.67x | ✅ | +| `hexstr_to_bytes['0x'+'b'*2048]` | 0.00013594383303039772 | 0.00011740238816895623 | 13.64% | 15.79% | 1.16x | ✅ | +| `hexstr_to_bytes['0x'+'badc0ffee0ddf00d'*4]` | 3.0637299606844215e-05 | 1.825061606833408e-05 | 40.43% | 67.87% | 1.68x | ✅ | +| `hexstr_to_bytes['0x'+'beef'*16]` | 3.0686441614538446e-05 | 1.828964146387517e-05 | 40.40% | 67.78% | 1.68x | ✅ | +| `hexstr_to_bytes['0x'+'c'*1024]` | 8.930193709352504e-05 | 7.109606211638662e-05 | 20.39% | 25.61% | 1.26x | ✅ | +| `hexstr_to_bytes['0x'+'cafebabe'*8]` | 3.088379314855554e-05 | 1.8427330656680643e-05 | 40.33% | 67.60% | 1.68x | ✅ | +| `hexstr_to_bytes['0x'+'d'*512]` | 5.7096419255965127e-05 | 4.083693236247332e-05 | 28.48% | 39.82% | 1.40x | ✅ | +| `hexstr_to_bytes['0x'+'dead'*16]` | 3.058232145729629e-05 | 1.809661975645168e-05 | 40.83% | 68.99% | 1.69x | ✅ | +| `hexstr_to_bytes['0x'+'e'*256]` | 4.3404514225927844e-05 | 2.765456002913683e-05 | 36.29% | 56.95% | 1.57x | ✅ | +| `hexstr_to_bytes['0x'+'f'*128]` | 3.399261691057168e-05 | 2.222686285822979e-05 | 34.61% | 52.93% | 1.53x | ✅ | +| `hexstr_to_bytes['0x'+'f'*64]` | 3.1021508877018215e-05 | 1.8116641999804634e-05 | 41.60% | 71.23% | 1.71x | ✅ | +| `hexstr_to_bytes['0x'+'facefeed'*8]` | 3.080530283390321e-05 | 1.836125208505399e-05 | 40.40% | 67.77% | 1.68x | ✅ | +| `hexstr_to_bytes['0x'+'ff'*32]` | 3.025273538705345e-05 | 1.869490905427472e-05 | 38.20% | 61.82% | 1.62x | ✅ | +| `hexstr_to_bytes['0x'+'ff00'*16]` | 3.133593755440466e-05 | 1.793547693437449e-05 | 42.76% | 74.71% | 1.75x | ✅ | +| `hexstr_to_bytes['0x']` | 2.2363566556968745e-05 | 1.0721175914161055e-05 | 52.06% | 108.59% | 2.09x | ✅ | +| `hexstr_to_bytes['0x0']` | 3.117668463108531e-05 | 1.8295366577069213e-05 | 41.32% | 70.41% | 1.70x | ✅ | +| `hexstr_to_bytes['0x1']` | 3.0849555815962966e-05 | 1.8261551169755883e-05 | 40.80% | 68.93% | 1.69x | ✅ | +| `hexstr_to_bytes['0x1234']` | 2.8017224899503598e-05 | 1.6290132930728818e-05 | 41.86% | 71.99% | 1.72x | ✅ | +| `hexstr_to_bytes['0xCAFEBABE']` | 2.8630167761260635e-05 | 1.590381517649548e-05 | 44.45% | 80.02% | 1.80x | ✅ | +| `hexstr_to_bytes['0xabcdef']` | 2.819579268732196e-05 | 1.6022231111650803e-05 | 43.18% | 75.98% | 1.76x | ✅ | +| `hexstr_to_bytes['0xdeadbeef']` | 2.830248157006902e-05 | 1.585293612257558e-05 | 43.99% | 78.53% | 1.79x | ✅ | +| `hexstr_to_bytes['deadbeef']` | 2.1769765855138907e-05 | 1.4235579165167571e-05 | 34.61% | 52.93% | 1.53x | ✅ | +| `to_bytes['']` | 2.780713012713541e-05 | 1.2309232769289748e-05 | 55.73% | 125.90% | 2.26x | ✅ | +| `to_bytes['0x'+'00'*64]` | 4.614754749205394e-05 | 2.454348694205276e-05 | 46.82% | 88.02% | 1.88x | ✅ | +| `to_bytes['0x'+'a'*128]` | 4.578380867751802e-05 | 2.2843051102385115e-05 | 50.11% | 100.43% | 2.00x | ✅ | +| `to_bytes['0x'+'ff'*32]` | 4.2892556366788844e-05 | 2.0060250794027318e-05 | 53.23% | 113.82% | 2.14x | ✅ | +| `to_bytes['0x']` | 3.378070519013953e-05 | 1.2405538866200987e-05 | 63.28% | 172.30% | 2.72x | ✅ | +| `to_bytes['0x1234']` | 4.0135614389222814e-05 | 1.7331320939841e-05 | 56.82% | 131.58% | 2.32x | ✅ | +| `to_bytes['0xCAFEBABE']` | 4.028950128859023e-05 | 1.7608736971127636e-05 | 56.29% | 128.80% | 2.29x | ✅ | +| `to_bytes['0xabcdef']` | 4.033539702017461e-05 | 1.7413172587315903e-05 | 56.83% | 131.64% | 2.32x | ✅ | +| `to_bytes['0xdeadbeef']` | 4.013742988293151e-05 | 1.753887938858019e-05 | 56.30% | 128.85% | 2.29x | ✅ | +| `to_bytes['abc']` | 3.626267484598067e-05 | 1.9475589274551575e-05 | 46.29% | 86.20% | 1.86x | ✅ | +| `to_bytes['deadbeef']` | 3.2121970134094524e-05 | 1.4998967326784364e-05 | 53.31% | 114.16% | 2.14x | ✅ | +| `to_bytes[0-9]` | 6.3886084044368e-06 | 3.6301764321770105e-06 | 43.18% | 75.99% | 1.76x | ✅ | +| `to_bytes[0]` | 7.379821878600025e-05 | 3.0514048254667094e-05 | 58.65% | 141.85% | 2.42x | ✅ | +| `to_bytes[123456]` | 7.73908812451048e-05 | 3.575842943020024e-05 | 53.80% | 116.43% | 2.16x | ✅ | +| `to_bytes[2**16]` | 7.617986899797664e-05 | 3.527787514997935e-05 | 53.69% | 115.94% | 2.16x | ✅ | +| `to_bytes[2**256-1]` | 8.129447794758294e-05 | 4.0483949767541644e-05 | 50.20% | 100.81% | 2.01x | ✅ | +| `to_bytes[2**32]` | 7.885789630365754e-05 | 3.807714350478118e-05 | 51.71% | 107.10% | 2.07x | ✅ | +| `to_bytes[2**64]` | 8.069210213483589e-05 | 3.965815884713019e-05 | 50.85% | 103.47% | 2.03x | ✅ | +| `to_bytes[2**8]` | 7.60528725562803e-05 | 3.317653912689118e-05 | 56.38% | 129.24% | 2.29x | ✅ | +| `to_bytes[4-byte pattern]` | 5.966323180854022e-06 | 3.3885955799150795e-06 | 43.20% | 76.07% | 1.76x | ✅ | +| `to_bytes[False]` | 2.132333374780846e-05 | 4.322555878144883e-06 | 79.73% | 393.30% | 4.93x | ✅ | +| `to_bytes[True]` | 2.114009323563744e-05 | 4.474505459519339e-06 | 78.83% | 372.46% | 4.72x | ✅ | +| `to_bytes[all byte values]` | 6.388727853404534e-06 | 3.6321036172973787e-06 | 43.15% | 75.90% | 1.76x | ✅ | +| `to_bytes[alternating 0x00/0xff]` | 6.363086431103152e-06 | 3.4449100293139135e-06 | 45.86% | 84.71% | 1.85x | ✅ | +| `to_bytes[alternating 0xaa/0x55]` | 6.278620315055821e-06 | 3.535981761329247e-06 | 43.68% | 77.56% | 1.78x | ✅ | +| `to_bytes[ascii sentence]` | 6.385267134108629e-06 | 3.7213794053924145e-06 | 41.72% | 71.58% | 1.72x | ✅ | +| `to_bytes[b'']` | 6.10807762546999e-06 | 3.559441642548437e-06 | 41.73% | 71.60% | 1.72x | ✅ | +| `to_bytes[b'\\x00'*32]` | 6.1997821267900955e-06 | 3.7227266437959667e-06 | 39.95% | 66.54% | 1.67x | ✅ | +| `to_bytes[b'\\x00\\xff\\x00\\xff']` | 6.115080140454961e-06 | 3.6294043971970026e-06 | 40.65% | 68.49% | 1.68x | ✅ | +| `to_bytes[b'\\x01'*100]` | 6.38729320124322e-06 | 3.629548274374021e-06 | 43.18% | 75.98% | 1.76x | ✅ | +| `to_bytes[b'\\x01'*2048]` | 6.392970547909741e-06 | 3.5681287886529697e-06 | 44.19% | 79.17% | 1.79x | ✅ | +| `to_bytes[b'\\x01\\x02\\x03']` | 6.214807194428287e-06 | 3.5724200907566754e-06 | 42.52% | 73.97% | 1.74x | ✅ | +| `to_bytes[b'\\x10\\x20\\x30\\x40\\x50']` | 6.384759732087906e-06 | 3.4718455445162805e-06 | 45.62% | 83.90% | 1.84x | ✅ | +| `to_bytes[b'\\x7f'*8]` | 6.2221944530742285e-06 | 3.6299630009677656e-06 | 41.66% | 71.41% | 1.71x | ✅ | +| `to_bytes[b'\\x80'*8]` | 6.154746823977371e-06 | 3.5098569762158247e-06 | 42.97% | 75.36% | 1.75x | ✅ | +| `to_bytes[b'\\xde\\xad\\xbe\\xef']` | 6.118508096629166e-06 | 3.5327114331565147e-06 | 42.26% | 73.20% | 1.73x | ✅ | +| `to_bytes[b'\\xff'*64]` | 6.228611346948233e-06 | 3.5638385534057674e-06 | 42.78% | 74.77% | 1.75x | ✅ | +| `to_bytes[b'a'*1024]` | 6.214476654822796e-06 | 3.6405793911024955e-06 | 41.42% | 70.70% | 1.71x | ✅ | +| `to_bytes[b'abc']` | 5.704947810781707e-06 | 3.6286094943273793e-06 | 36.40% | 57.22% | 1.57x | ✅ | +| `to_bytes[bytearray(0-9)]` | 2.8385540980501474e-05 | 1.3892159525838066e-05 | 51.06% | 104.33% | 2.04x | ✅ | +| `to_bytes[bytearray(4-byte pattern)]` | 2.827050900870094e-05 | 1.4056222794783555e-05 | 50.28% | 101.12% | 2.01x | ✅ | +| `to_bytes[bytearray(all byte values)]` | 2.877292936670269e-05 | 1.435422533320354e-05 | 50.11% | 100.45% | 2.00x | ✅ | +| `to_bytes[bytearray(alternating 0x00/0xff)]` | 2.8227929229195593e-05 | 1.3651875261692757e-05 | 51.64% | 106.77% | 2.07x | ✅ | +| `to_bytes[bytearray(alternating 0xaa/0x55)]` | 2.837463577403303e-05 | 1.4085501772100954e-05 | 50.36% | 101.45% | 2.01x | ✅ | +| `to_bytes[bytearray(ascii sentence)]` | 2.788046431872048e-05 | 1.4073893727957965e-05 | 49.52% | 98.10% | 1.98x | ✅ | +| `to_bytes[bytearray(b'')]` | 2.5972620905868233e-05 | 1.2685871938856117e-05 | 51.16% | 104.74% | 2.05x | ✅ | +| `to_bytes[bytearray(b'\\x00'*32)]` | 2.790329559512333e-05 | 1.403080114449928e-05 | 49.72% | 98.87% | 1.99x | ✅ | +| `to_bytes[bytearray(b'\\x00\\xff\\x00\\xff')]` | 2.7745585095988548e-05 | 1.4024106217358874e-05 | 49.45% | 97.84% | 1.98x | ✅ | +| `to_bytes[bytearray(b'\\x01'*100)]` | 2.8536359978812884e-05 | 1.4236424049013974e-05 | 50.11% | 100.45% | 2.00x | ✅ | +| `to_bytes[bytearray(b'\\x01'*2048)]` | 3.549077378005222e-05 | 1.9352766224829574e-05 | 45.47% | 83.39% | 1.83x | ✅ | +| `to_bytes[bytearray(b'\\x01\\x02\\x03')]` | 2.8101052165112413e-05 | 1.4292128556009155e-05 | 49.14% | 96.62% | 1.97x | ✅ | +| `to_bytes[bytearray(b'\\x10\\x20\\x30\\x40\\x50')]` | 2.7661397342967836e-05 | 1.4095613005042919e-05 | 49.04% | 96.24% | 1.96x | ✅ | +| `to_bytes[bytearray(b'\\x7f'*8)]` | 2.725931521432537e-05 | 1.3800682471510037e-05 | 49.37% | 97.52% | 1.98x | ✅ | +| `to_bytes[bytearray(b'\\x80'*8)]` | 2.8590031839184632e-05 | 1.4021589244572647e-05 | 50.96% | 103.90% | 2.04x | ✅ | +| `to_bytes[bytearray(b'\\xde\\xad\\xbe\\xef')]` | 2.7673809875166307e-05 | 1.3955245016922358e-05 | 49.57% | 98.30% | 1.98x | ✅ | +| `to_bytes[bytearray(b'\\xff'*64)]` | 2.7825869941964144e-05 | 1.397535630887856e-05 | 49.78% | 99.11% | 1.99x | ✅ | +| `to_bytes[bytearray(b'a'*1024)]` | 3.4580409459484653e-05 | 1.8673202446672093e-05 | 46.00% | 85.19% | 1.85x | ✅ | +| `to_bytes[bytearray(b'abc')]` | 2.7632051275317663e-05 | 1.4212278275687856e-05 | 48.57% | 94.42% | 1.94x | ✅ | +| `to_bytes[bytearray(long alternating)]` | 3.447633488580355e-05 | 1.863387225839248e-05 | 45.95% | 85.02% | 1.85x | ✅ | +| `to_bytes[bytearray(mixed pattern)]` | 2.8541322877722866e-05 | 1.4195507938501473e-05 | 50.26% | 101.06% | 2.01x | ✅ | +| `to_bytes[bytearray(multiples of 0x10)]` | 2.8730667094271124e-05 | 1.4011019797634606e-05 | 51.23% | 105.06% | 2.05x | ✅ | +| `to_bytes[bytearray(palindrome ascii)]` | 2.8401192649128307e-05 | 1.3961644776858775e-05 | 50.84% | 103.42% | 2.03x | ✅ | +| `to_bytes[bytearray(palindrome numeric)]` | 2.805100416648689e-05 | 1.4152590803546867e-05 | 49.55% | 98.20% | 1.98x | ✅ | +| `to_bytes[bytearray(palindrome)]` | 2.7361673603877895e-05 | 1.411429298192429e-05 | 48.42% | 93.86% | 1.94x | ✅ | +| `to_bytes[bytearray(repeated 0-9)]` | 2.8494565334918126e-05 | 1.4258424138299958e-05 | 49.96% | 99.84% | 2.00x | ✅ | +| `to_bytes[bytearray(single 0xff)]` | 2.8234466593201184e-05 | 1.3801473578009802e-05 | 51.12% | 104.58% | 2.05x | ✅ | +| `to_bytes[bytearray(single null byte)]` | 2.8434517722019846e-05 | 1.3809952582861235e-05 | 51.43% | 105.90% | 2.06x | ✅ | +| `to_bytes[bytearray(two patterns)]` | 2.836216679184966e-05 | 1.3887588637424222e-05 | 51.03% | 104.23% | 2.04x | ✅ | +| `to_bytes[long alternating]` | 6.353790402607213e-06 | 3.5938990087545537e-06 | 43.44% | 76.79% | 1.77x | ✅ | +| `to_bytes[memoryview(0-9)]` | 4.191141964546983e-05 | 1.7061112356892058e-05 | 59.29% | 145.65% | 2.46x | ✅ | +| `to_bytes[memoryview(4-byte pattern)]` | 4.227527549170472e-05 | 1.785782064892619e-05 | 57.76% | 136.73% | 2.37x | ✅ | +| `to_bytes[memoryview(all byte values)]` | 4.25000108585221e-05 | 1.7688601774026213e-05 | 58.38% | 140.27% | 2.40x | ✅ | +| `to_bytes[memoryview(alternating 0x00/0xff)]` | 4.1347704048452746e-05 | 1.6650846971237402e-05 | 59.73% | 148.32% | 2.48x | ✅ | +| `to_bytes[memoryview(alternating 0xaa/0x55)]` | 4.171208060914525e-05 | 1.675602408003079e-05 | 59.83% | 148.94% | 2.49x | ✅ | +| `to_bytes[memoryview(ascii sentence)]` | 4.166324952645984e-05 | 1.709207709767455e-05 | 58.98% | 143.76% | 2.44x | ✅ | +| `to_bytes[memoryview(b'')]` | 3.925414926485738e-05 | 1.5303932766174733e-05 | 61.01% | 156.50% | 2.56x | ✅ | +| `to_bytes[memoryview(b'\\x00'*32)]` | 4.1375511773526405e-05 | 1.6976747870806958e-05 | 58.97% | 143.72% | 2.44x | ✅ | +| `to_bytes[memoryview(b'\\x00\\xff\\x00\\xff')]` | 4.106893288361651e-05 | 1.7061131875227936e-05 | 58.46% | 140.72% | 2.41x | ✅ | +| `to_bytes[memoryview(b'\\x01'*100)]` | 4.193922634521223e-05 | 1.7745782258368427e-05 | 57.69% | 136.33% | 2.36x | ✅ | +| `to_bytes[memoryview(b'\\x01'*2048)]` | 5.0798682929570083e-05 | 2.40390666370428e-05 | 52.68% | 111.32% | 2.11x | ✅ | +| `to_bytes[memoryview(b'\\x01\\x02\\x03')]` | 4.036702557146768e-05 | 1.7250564311840054e-05 | 57.27% | 134.00% | 2.34x | ✅ | +| `to_bytes[memoryview(b'\\x10\\x20\\x30\\x40\\x50')]` | 4.175508032041267e-05 | 1.6957717517602734e-05 | 59.39% | 146.23% | 2.46x | ✅ | +| `to_bytes[memoryview(b'\\x7f'*8)]` | 4.1358438818942784e-05 | 1.6817791110631697e-05 | 59.34% | 145.92% | 2.46x | ✅ | +| `to_bytes[memoryview(b'\\x80'*8)]` | 4.203092161038334e-05 | 1.681154500200111e-05 | 60.00% | 150.01% | 2.50x | ✅ | +| `to_bytes[memoryview(b'\\xde\\xad\\xbe\\xef')]` | 4.231867737850461e-05 | 1.6846002165597455e-05 | 60.19% | 151.21% | 2.51x | ✅ | +| `to_bytes[memoryview(b'\\xff'*64)]` | 4.126073396736014e-05 | 1.6694308190545488e-05 | 59.54% | 147.15% | 2.47x | ✅ | +| `to_bytes[memoryview(b'a'*1024)]` | 4.88048523792244e-05 | 2.4008626930621554e-05 | 50.81% | 103.28% | 2.03x | ✅ | +| `to_bytes[memoryview(b'abc')]` | 4.134610001372583e-05 | 1.7269193990729754e-05 | 58.23% | 139.42% | 2.39x | ✅ | +| `to_bytes[memoryview(long alternating)]` | 4.8406942144499424e-05 | 2.388143899713461e-05 | 50.67% | 102.70% | 2.03x | ✅ | +| `to_bytes[memoryview(mixed pattern)]` | 4.167505874201827e-05 | 1.7698671546729557e-05 | 57.53% | 135.47% | 2.35x | ✅ | +| `to_bytes[memoryview(multiples of 0x10)]` | 4.2573899493451105e-05 | 1.705716143319723e-05 | 59.94% | 149.60% | 2.50x | ✅ | +| `to_bytes[memoryview(palindrome ascii)]` | 4.147093203068994e-05 | 1.6858821327193028e-05 | 59.35% | 145.99% | 2.46x | ✅ | +| `to_bytes[memoryview(palindrome numeric)]` | 4.2052385986215005e-05 | 1.6783240695512243e-05 | 60.09% | 150.56% | 2.51x | ✅ | +| `to_bytes[memoryview(palindrome)]` | 4.010310828456553e-05 | 1.6841586810144283e-05 | 58.00% | 138.12% | 2.38x | ✅ | +| `to_bytes[memoryview(repeated 0-9)]` | 4.2346341955859134e-05 | 1.7627392408451933e-05 | 58.37% | 140.23% | 2.40x | ✅ | +| `to_bytes[memoryview(single 0xff)]` | 4.154646686337471e-05 | 1.708420634946452e-05 | 58.88% | 143.19% | 2.43x | ✅ | +| `to_bytes[memoryview(single null byte)]` | 4.1426186115767904e-05 | 1.7216447723124524e-05 | 58.44% | 140.62% | 2.41x | ✅ | +| `to_bytes[memoryview(two patterns)]` | 4.120532411573023e-05 | 1.6795418517469898e-05 | 59.24% | 145.34% | 2.45x | ✅ | +| `to_bytes[mixed pattern]` | 6.402295260899727e-06 | 3.6240499846615196e-06 | 43.39% | 76.66% | 1.77x | ✅ | +| `to_bytes[multiples of 0x10]` | 6.11021314345847e-06 | 3.5831417482492563e-06 | 41.36% | 70.53% | 1.71x | ✅ | +| `to_bytes[palindrome ascii]` | 6.034686767709764e-06 | 3.5377684971786242e-06 | 41.38% | 70.58% | 1.71x | ✅ | +| `to_bytes[palindrome numeric]` | 6.402815719286604e-06 | 3.659680142558091e-06 | 42.84% | 74.96% | 1.75x | ✅ | +| `to_bytes[palindrome]` | 5.802467693826409e-06 | 3.521160495735191e-06 | 39.32% | 64.79% | 1.65x | ✅ | +| `to_bytes[repeated 0-9]` | 6.383479853505014e-06 | 3.638034291718348e-06 | 43.01% | 75.47% | 1.75x | ✅ | +| `to_bytes[single 0xff]` | 6.267069994516826e-06 | 3.559259039534453e-06 | 43.21% | 76.08% | 1.76x | ✅ | +| `to_bytes[single null byte]` | 6.26625804427524e-06 | 3.271624181759306e-06 | 47.79% | 91.53% | 1.92x | ✅ | +| `to_bytes[two patterns]` | 6.347030519900153e-06 | 3.5394506816199115e-06 | 44.23% | 79.32% | 1.79x | ✅ | diff --git a/benchmarks/results/main.md b/benchmarks/results/main.md new file mode 100644 index 0000000..b4be1f4 --- /dev/null +++ b/benchmarks/results/main.md @@ -0,0 +1,486 @@ +#### [faster_hexbytes.main](https://github.com/BobTheBuidler/faster-hexbytes/blob/benchmark/faster_hexbytes/main.py) - [view benchmarks](https://github.com/BobTheBuidler/faster-hexbytes/blob/benchmark/benchmarks/test_main_benchmarks.py) + +| Function | Reference Mean | Faster Mean | % Change | Speedup (%) | x Faster | Faster | +|----------|---------------|-------------|----------|-------------|----------|--------| +| `hexbytes_getitem_index[-1-0-9]` | 2.4847447452029246e-05 | 2.3450026731823607e-05 | 5.62% | 5.96% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-4-byte pattern]` | 2.446805682924332e-05 | 2.3635641231548687e-05 | 3.40% | 3.52% | 1.04x | ✅ | +| `hexbytes_getitem_index[-1-all byte values]` | 2.4726612057580454e-05 | 2.3407566330406905e-05 | 5.33% | 5.64% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-alternating 0x00/0xff]` | 2.4731667416142e-05 | 2.3283497082720465e-05 | 5.86% | 6.22% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-alternating 0xaa/0x55]` | 2.4523115479161836e-05 | 2.3346323921959994e-05 | 4.80% | 5.04% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-ascii sentence]` | 2.471176627058649e-05 | 2.3615962469828527e-05 | 4.43% | 4.64% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x00'*32]` | 2.4777311257616818e-05 | 2.3405050535681556e-05 | 5.54% | 5.86% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x00\\xff\\x00\\xff']` | 2.4313481344212053e-05 | 2.3204503403589972e-05 | 4.56% | 4.78% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x01'*100]` | 2.468310354706276e-05 | 2.327476042499668e-05 | 5.71% | 6.05% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x01'*2048]` | 2.4854226475343243e-05 | 2.3390127621197537e-05 | 5.89% | 6.26% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x01\\x02\\x03']` | 2.4745279930320675e-05 | 2.3522761413737913e-05 | 4.94% | 5.20% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x10\\x20\\x30\\x40\\x50']` | 2.438506663016707e-05 | 2.3257755613599015e-05 | 4.62% | 4.85% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x7f'*8]` | 2.4743313419518356e-05 | 2.3370369649475358e-05 | 5.55% | 5.87% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'\\x80'*8]` | 2.4816026228816605e-05 | 2.3249313657766363e-05 | 6.31% | 6.74% | 1.07x | ✅ | +| `hexbytes_getitem_index[-1-b'\\xde\\xad\\xbe\\xef']` | 2.448254310611167e-05 | 2.3316949833370263e-05 | 4.76% | 5.00% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-b'\\xff'*64]` | 2.4849436712534857e-05 | 2.3344878336245734e-05 | 6.05% | 6.44% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'a'*1024]` | 2.493238498788441e-05 | 2.3606790961815634e-05 | 5.32% | 5.62% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-b'abc']` | 2.4834496919024717e-05 | 2.3382304411471888e-05 | 5.85% | 6.21% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-long alternating]` | 2.4615057704326276e-05 | 2.3430983714349e-05 | 4.81% | 5.05% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-mixed pattern]` | 2.4671778626251292e-05 | 2.3627064998301808e-05 | 4.23% | 4.42% | 1.04x | ✅ | +| `hexbytes_getitem_index[-1-multiples of 0x10]` | 2.468829805610535e-05 | 2.3326285352224695e-05 | 5.52% | 5.84% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-palindrome ascii]` | 2.4370598961263974e-05 | 2.338947068419359e-05 | 4.03% | 4.19% | 1.04x | ✅ | +| `hexbytes_getitem_index[-1-palindrome numeric]` | 2.4579864556403647e-05 | 2.3370869518498163e-05 | 4.92% | 5.17% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-palindrome]` | 2.4879236943731623e-05 | 2.3387243476769648e-05 | 6.00% | 6.38% | 1.06x | ✅ | +| `hexbytes_getitem_index[-1-repeated 0-9]` | 2.448997201236898e-05 | 2.3253474233650765e-05 | 5.05% | 5.32% | 1.05x | ✅ | +| `hexbytes_getitem_index[-1-two patterns]` | 2.450192796439518e-05 | 2.357708117878136e-05 | 3.77% | 3.92% | 1.04x | ✅ | +| `hexbytes_getitem_index[0-0-9]` | 2.3640609440231097e-05 | 2.232804370059225e-05 | 5.55% | 5.88% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-4-byte pattern]` | 2.373320584882109e-05 | 2.233125115448439e-05 | 5.91% | 6.28% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-all byte values]` | 2.3559061122321206e-05 | 2.2250773621945793e-05 | 5.55% | 5.88% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-alternating 0x00/0xff]` | 2.3749435700519763e-05 | 2.218071530181339e-05 | 6.61% | 7.07% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-alternating 0xaa/0x55]` | 2.3719266900758352e-05 | 2.2353831626638472e-05 | 5.76% | 6.11% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-ascii sentence]` | 2.3597481287196645e-05 | 2.2091971995881697e-05 | 6.38% | 6.81% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-b'\\x00'*32]` | 2.392226984110175e-05 | 2.2037988705510813e-05 | 7.88% | 8.55% | 1.09x | ✅ | +| `hexbytes_getitem_index[0-b'\\x00\\xff\\x00\\xff']` | 2.3727784820388614e-05 | 2.2021295173813944e-05 | 7.19% | 7.75% | 1.08x | ✅ | +| `hexbytes_getitem_index[0-b'\\x01'*100]` | 2.3659152481324694e-05 | 2.2252363327119516e-05 | 5.95% | 6.32% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-b'\\x01'*2048]` | 2.3578475937046213e-05 | 2.230988678238333e-05 | 5.38% | 5.69% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-b'\\x01\\x02\\x03']` | 2.3631310564377923e-05 | 2.2118711270966876e-05 | 6.40% | 6.84% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-b'\\x10\\x20\\x30\\x40\\x50']` | 2.372311879146398e-05 | 2.213856237305192e-05 | 6.68% | 7.16% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-b'\\x7f'*8]` | 2.3915516289643552e-05 | 2.2307433582913363e-05 | 6.72% | 7.21% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-b'\\x80'*8]` | 2.3735412525488777e-05 | 2.2230167485098905e-05 | 6.34% | 6.77% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-b'\\xde\\xad\\xbe\\xef']` | 2.3683889844274444e-05 | 2.2163847819654035e-05 | 6.42% | 6.86% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-b'\\xff'*64]` | 2.4175792186616108e-05 | 2.200889907538998e-05 | 8.96% | 9.85% | 1.10x | ✅ | +| `hexbytes_getitem_index[0-b'a'*1024]` | 2.3862376567425472e-05 | 2.2006472774346828e-05 | 7.78% | 8.43% | 1.08x | ✅ | +| `hexbytes_getitem_index[0-b'abc']` | 2.3732148887069292e-05 | 2.2575495507843222e-05 | 4.87% | 5.12% | 1.05x | ✅ | +| `hexbytes_getitem_index[0-long alternating]` | 2.3670516671074392e-05 | 2.2302816885162254e-05 | 5.78% | 6.13% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-mixed pattern]` | 2.369279636677286e-05 | 2.1967241132713774e-05 | 7.28% | 7.86% | 1.08x | ✅ | +| `hexbytes_getitem_index[0-multiples of 0x10]` | 2.3713163133561152e-05 | 2.2395580512059475e-05 | 5.56% | 5.88% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-palindrome ascii]` | 2.372535189391524e-05 | 2.2258396730235407e-05 | 6.18% | 6.59% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-palindrome numeric]` | 2.375859390888847e-05 | 2.2285298064844566e-05 | 6.20% | 6.61% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-palindrome]` | 2.363382163680642e-05 | 2.2135741423325648e-05 | 6.34% | 6.77% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-repeated 0-9]` | 2.3882651063446776e-05 | 2.2259791641842352e-05 | 6.80% | 7.29% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-single 0xff]` | 2.3767333200041022e-05 | 2.2120169400764797e-05 | 6.93% | 7.45% | 1.07x | ✅ | +| `hexbytes_getitem_index[0-single null byte]` | 2.3618790092504198e-05 | 2.2262308923352927e-05 | 5.74% | 6.09% | 1.06x | ✅ | +| `hexbytes_getitem_index[0-two patterns]` | 2.365909050841332e-05 | 2.2210445110527486e-05 | 6.12% | 6.52% | 1.07x | ✅ | +| `hexbytes_getitem_index[1-0-9]` | 2.350437963646178e-05 | 2.230597783626155e-05 | 5.10% | 5.37% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-4-byte pattern]` | 2.3388753001021146e-05 | 2.241563514334635e-05 | 4.16% | 4.34% | 1.04x | ✅ | +| `hexbytes_getitem_index[1-all byte values]` | 2.3389290477161366e-05 | 2.222879750713185e-05 | 4.96% | 5.22% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-alternating 0x00/0xff]` | 2.3624362951330394e-05 | 2.228589793267534e-05 | 5.67% | 6.01% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-alternating 0xaa/0x55]` | 2.3597960178016714e-05 | 2.2363680838750865e-05 | 5.23% | 5.52% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-ascii sentence]` | 2.3531461388181766e-05 | 2.2335075747968907e-05 | 5.08% | 5.36% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-b'\\x00'*32]` | 2.3747036836208635e-05 | 2.2402921023370407e-05 | 5.66% | 6.00% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-b'\\x00\\xff\\x00\\xff']` | 2.359141030040157e-05 | 2.2419787480451866e-05 | 4.97% | 5.23% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-b'\\x01'*100]` | 2.351381044957054e-05 | 2.2326575628342087e-05 | 5.05% | 5.32% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-b'\\x01'*2048]` | 2.3430996963478045e-05 | 2.2274605783180455e-05 | 4.94% | 5.19% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-b'\\x01\\x02\\x03']` | 2.3524676320574997e-05 | 2.2310255654855533e-05 | 5.16% | 5.44% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3733780166228564e-05 | 2.2327814863199725e-05 | 5.92% | 6.30% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-b'\\x7f'*8]` | 2.3687369965297325e-05 | 2.240640951745013e-05 | 5.41% | 5.72% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-b'\\x80'*8]` | 2.3397852464771586e-05 | 2.192985444328968e-05 | 6.27% | 6.69% | 1.07x | ✅ | +| `hexbytes_getitem_index[1-b'\\xde\\xad\\xbe\\xef']` | 2.368834322710453e-05 | 2.2273048897882523e-05 | 5.97% | 6.35% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-b'\\xff'*64]` | 2.3485814293986674e-05 | 2.231628684523511e-05 | 4.98% | 5.24% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-b'a'*1024]` | 2.386470804413667e-05 | 2.2281061209550367e-05 | 6.64% | 7.11% | 1.07x | ✅ | +| `hexbytes_getitem_index[1-b'abc']` | 2.3691218604520744e-05 | 2.2422567641292406e-05 | 5.35% | 5.66% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-long alternating]` | 2.3648119368974904e-05 | 2.2379031486075737e-05 | 5.37% | 5.67% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-mixed pattern]` | 2.347146341953654e-05 | 2.229130324896944e-05 | 5.03% | 5.29% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-multiples of 0x10]` | 2.353816276859851e-05 | 2.2144607709767796e-05 | 5.92% | 6.29% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-palindrome ascii]` | 2.3612440878305855e-05 | 2.2357479185841583e-05 | 5.31% | 5.61% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-palindrome numeric]` | 2.3520370890261427e-05 | 2.2218627957983257e-05 | 5.53% | 5.86% | 1.06x | ✅ | +| `hexbytes_getitem_index[1-palindrome]` | 2.3657794497085767e-05 | 2.256005699098937e-05 | 4.64% | 4.87% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-repeated 0-9]` | 2.343486460477775e-05 | 2.2357192532938336e-05 | 4.60% | 4.82% | 1.05x | ✅ | +| `hexbytes_getitem_index[1-two patterns]` | 2.3571511712386594e-05 | 2.2294920635925086e-05 | 5.42% | 5.73% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-0-9]` | 2.376859702714776e-05 | 2.240866077092658e-05 | 5.72% | 6.07% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-4-byte pattern]` | 2.3971286041117216e-05 | 2.232290985420918e-05 | 6.88% | 7.38% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-all byte values]` | 2.3814855939904812e-05 | 2.2196273233205883e-05 | 6.80% | 7.29% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-alternating 0x00/0xff]` | 2.390055381360492e-05 | 2.2330467329889835e-05 | 6.57% | 7.03% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-alternating 0xaa/0x55]` | 2.3807921178646178e-05 | 2.2431680109115197e-05 | 5.78% | 6.14% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-ascii sentence]` | 2.3365220473568995e-05 | 2.2343897980482263e-05 | 4.37% | 4.57% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-b'\\x00'*32]` | 2.3375625650513347e-05 | 2.2390547339726867e-05 | 4.21% | 4.40% | 1.04x | ✅ | +| `hexbytes_getitem_index[2-b'\\x00\\xff\\x00\\xff']` | 2.350530882275377e-05 | 2.218305857151874e-05 | 5.63% | 5.96% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-b'\\x01'*100]` | 2.3425987917706524e-05 | 2.2096632828754697e-05 | 5.67% | 6.02% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-b'\\x01'*2048]` | 2.3927392356409264e-05 | 2.2239041943430718e-05 | 7.06% | 7.59% | 1.08x | ✅ | +| `hexbytes_getitem_index[2-b'\\x01\\x02\\x03']` | 2.3640994193771224e-05 | 2.2206297555999423e-05 | 6.07% | 6.46% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-b'\\x10\\x20\\x30\\x40\\x50']` | 2.374901494471697e-05 | 2.2245854974556628e-05 | 6.33% | 6.76% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-b'\\x7f'*8]` | 2.3410950031940884e-05 | 2.1972938435673387e-05 | 6.14% | 6.54% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-b'\\x80'*8]` | 2.3365199463743537e-05 | 2.22919694642195e-05 | 4.59% | 4.81% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-b'\\xde\\xad\\xbe\\xef']` | 2.365441097718043e-05 | 2.2245648112737955e-05 | 5.96% | 6.33% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-b'\\xff'*64]` | 2.35864065938133e-05 | 2.231155832021235e-05 | 5.41% | 5.71% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-b'a'*1024]` | 2.323605423398757e-05 | 2.4404525747935898e-05 | -5.03% | -4.79% | 0.95x | ❌ | +| `hexbytes_getitem_index[2-b'abc']` | 2.3722461264859212e-05 | 2.2385468150396267e-05 | 5.64% | 5.97% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-long alternating]` | 2.3847633974548234e-05 | 2.2236601070996807e-05 | 6.76% | 7.24% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-mixed pattern]` | 2.3826645668796012e-05 | 2.2248675041882893e-05 | 6.62% | 7.09% | 1.07x | ✅ | +| `hexbytes_getitem_index[2-multiples of 0x10]` | 2.3607274029087297e-05 | 2.238016502011036e-05 | 5.20% | 5.48% | 1.05x | ✅ | +| `hexbytes_getitem_index[2-palindrome ascii]` | 2.3843746513752824e-05 | 2.2074706956929303e-05 | 7.42% | 8.01% | 1.08x | ✅ | +| `hexbytes_getitem_index[2-palindrome numeric]` | 2.384995983697482e-05 | 2.2168935214868402e-05 | 7.05% | 7.58% | 1.08x | ✅ | +| `hexbytes_getitem_index[2-palindrome]` | 2.3353639762196912e-05 | 2.3184971391492197e-05 | 0.72% | 0.73% | 1.01x | ✅ | +| `hexbytes_getitem_index[2-repeated 0-9]` | 2.3479222769940935e-05 | 2.2220355241910037e-05 | 5.36% | 5.67% | 1.06x | ✅ | +| `hexbytes_getitem_index[2-two patterns]` | 2.3870436406362992e-05 | 2.2326472681800106e-05 | 6.47% | 6.92% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-0-9]` | 2.346875938372422e-05 | 2.240947646466136e-05 | 4.51% | 4.73% | 1.05x | ✅ | +| `hexbytes_getitem_index[3-4-byte pattern]` | 2.3721855409706934e-05 | 2.222300970933843e-05 | 6.32% | 6.74% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-all byte values]` | 2.390814788126935e-05 | 2.283953127459055e-05 | 4.47% | 4.68% | 1.05x | ✅ | +| `hexbytes_getitem_index[3-alternating 0x00/0xff]` | 2.3669588520335587e-05 | 2.2366387821447823e-05 | 5.51% | 5.83% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-alternating 0xaa/0x55]` | 2.37963607593483e-05 | 2.243596847380388e-05 | 5.72% | 6.06% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-ascii sentence]` | 2.385759012590493e-05 | 2.2598322450417e-05 | 5.28% | 5.57% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-b'\\x00'*32]` | 2.3505933187042217e-05 | 2.224940013158834e-05 | 5.35% | 5.65% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-b'\\x00\\xff\\x00\\xff']` | 2.3560394405510724e-05 | 2.2325916175874644e-05 | 5.24% | 5.53% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-b'\\x01'*100]` | 2.3743939819745725e-05 | 2.2253526385851708e-05 | 6.28% | 6.70% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-b'\\x01'*2048]` | 2.3905277881044007e-05 | 2.2377902060079857e-05 | 6.39% | 6.83% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3647841778410742e-05 | 2.2284219330703748e-05 | 5.77% | 6.12% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-b'\\x7f'*8]` | 2.3583389431878405e-05 | 2.2293803599500448e-05 | 5.47% | 5.78% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-b'\\x80'*8]` | 2.3722950242620407e-05 | 2.2286066181847813e-05 | 6.06% | 6.45% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-b'\\xde\\xad\\xbe\\xef']` | 2.3845356834118778e-05 | 2.212288604441631e-05 | 7.22% | 7.79% | 1.08x | ✅ | +| `hexbytes_getitem_index[3-b'\\xff'*64]` | 2.3719538098640988e-05 | 2.2142743590668913e-05 | 6.65% | 7.12% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-b'a'*1024]` | 2.3485133845154906e-05 | 2.2153670264862265e-05 | 5.67% | 6.01% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-long alternating]` | 2.388198217001513e-05 | 2.22183555885802e-05 | 6.97% | 7.49% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-mixed pattern]` | 2.388614646004389e-05 | 2.2712403800206335e-05 | 4.91% | 5.17% | 1.05x | ✅ | +| `hexbytes_getitem_index[3-multiples of 0x10]` | 2.387063951538705e-05 | 2.230592252192809e-05 | 6.55% | 7.01% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-palindrome ascii]` | 2.389725274772817e-05 | 2.2360159584640115e-05 | 6.43% | 6.87% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-palindrome numeric]` | 2.3798089009595062e-05 | 2.2526916278931338e-05 | 5.34% | 5.64% | 1.06x | ✅ | +| `hexbytes_getitem_index[3-palindrome]` | 2.3655942653303613e-05 | 2.213796458225677e-05 | 6.42% | 6.86% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-repeated 0-9]` | 2.396342222639396e-05 | 2.2323883357804693e-05 | 6.84% | 7.34% | 1.07x | ✅ | +| `hexbytes_getitem_index[3-two patterns]` | 2.385684287372088e-05 | 2.2693310760618144e-05 | 4.88% | 5.13% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-0-9]` | 2.3899973992024223e-05 | 2.2453763928799237e-05 | 6.05% | 6.44% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-4-byte pattern]` | 2.3705508776158425e-05 | 2.238011738911868e-05 | 5.59% | 5.92% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-all byte values]` | 2.377875104005379e-05 | 2.22712890085195e-05 | 6.34% | 6.77% | 1.07x | ✅ | +| `hexbytes_getitem_index[4-alternating 0x00/0xff]` | 2.3802997980227825e-05 | 2.25064045339907e-05 | 5.45% | 5.76% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-alternating 0xaa/0x55]` | 2.3656997750980488e-05 | 2.246474914798274e-05 | 5.04% | 5.31% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-ascii sentence]` | 2.3889494842101873e-05 | 2.2232110147189814e-05 | 6.94% | 7.45% | 1.07x | ✅ | +| `hexbytes_getitem_index[4-b'\\x00'*32]` | 2.3948612391353527e-05 | 2.2580159784875707e-05 | 5.71% | 6.06% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-b'\\x01'*100]` | 2.36230588877441e-05 | 2.2538682146090458e-05 | 4.59% | 4.81% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-b'\\x01'*2048]` | 2.354046874295225e-05 | 2.2404037494145434e-05 | 4.83% | 5.07% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3690927947699704e-05 | 2.2461979332169837e-05 | 5.19% | 5.47% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-b'\\x7f'*8]` | 2.3799501582564888e-05 | 2.225404823020082e-05 | 6.49% | 6.94% | 1.07x | ✅ | +| `hexbytes_getitem_index[4-b'\\x80'*8]` | 2.364995371200852e-05 | 2.2431861192374475e-05 | 5.15% | 5.43% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-b'\\xff'*64]` | 2.3899208143721178e-05 | 2.2336480376619072e-05 | 6.54% | 7.00% | 1.07x | ✅ | +| `hexbytes_getitem_index[4-b'a'*1024]` | 2.388219329567692e-05 | 2.237994391119528e-05 | 6.29% | 6.71% | 1.07x | ✅ | +| `hexbytes_getitem_index[4-long alternating]` | 2.3825226326260514e-05 | 2.235339194559478e-05 | 6.18% | 6.58% | 1.07x | ✅ | +| `hexbytes_getitem_index[4-mixed pattern]` | 2.4263073550289538e-05 | 2.2477951042731033e-05 | 7.36% | 7.94% | 1.08x | ✅ | +| `hexbytes_getitem_index[4-multiples of 0x10]` | 2.3839900411638854e-05 | 2.2410074104850746e-05 | 6.00% | 6.38% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-palindrome ascii]` | 2.413395342536019e-05 | 2.2403790136882604e-05 | 7.17% | 7.72% | 1.08x | ✅ | +| `hexbytes_getitem_index[4-palindrome numeric]` | 2.386539608948987e-05 | 2.2444926049628023e-05 | 5.95% | 6.33% | 1.06x | ✅ | +| `hexbytes_getitem_index[4-palindrome]` | 2.3624708736914828e-05 | 2.2501062408512196e-05 | 4.76% | 4.99% | 1.05x | ✅ | +| `hexbytes_getitem_index[4-repeated 0-9]` | 2.4036002099408217e-05 | 2.2293087839859523e-05 | 7.25% | 7.82% | 1.08x | ✅ | +| `hexbytes_getitem_index[4-two patterns]` | 2.377668644820311e-05 | 2.2229137838792795e-05 | 6.51% | 6.96% | 1.07x | ✅ | +| `hexbytes_getitem_index[5-0-9]` | 2.3804482853094745e-05 | 2.2123400947219126e-05 | 7.06% | 7.60% | 1.08x | ✅ | +| `hexbytes_getitem_index[5-4-byte pattern]` | 2.3919398750660017e-05 | 2.2342013515976855e-05 | 6.59% | 7.06% | 1.07x | ✅ | +| `hexbytes_getitem_index[5-all byte values]` | 2.381642502048813e-05 | 2.225679471078651e-05 | 6.55% | 7.01% | 1.07x | ✅ | +| `hexbytes_getitem_index[5-alternating 0x00/0xff]` | 2.3850033761120395e-05 | 2.242768382035353e-05 | 5.96% | 6.34% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-alternating 0xaa/0x55]` | 2.3859982486855523e-05 | 2.185253475627353e-05 | 8.41% | 9.19% | 1.09x | ✅ | +| `hexbytes_getitem_index[5-ascii sentence]` | 2.3835025727299785e-05 | 2.2395683686574797e-05 | 6.04% | 6.43% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-b'\\x00'*32]` | 2.3798403675411692e-05 | 2.2465672940989854e-05 | 5.60% | 5.93% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-b'\\x01'*100]` | 2.3492257981176665e-05 | 2.2142185976849883e-05 | 5.75% | 6.10% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-b'\\x01'*2048]` | 2.366747898620313e-05 | 2.2198146171781466e-05 | 6.21% | 6.62% | 1.07x | ✅ | +| `hexbytes_getitem_index[5-b'\\x7f'*8]` | 2.35597953145184e-05 | 2.2171523646048525e-05 | 5.89% | 6.26% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-b'\\x80'*8]` | 2.3860267252043716e-05 | 2.2325881149106178e-05 | 6.43% | 6.87% | 1.07x | ✅ | +| `hexbytes_getitem_index[5-b'\\xff'*64]` | 2.38133876111381e-05 | 2.221470970606235e-05 | 6.71% | 7.20% | 1.07x | ✅ | +| `hexbytes_getitem_index[5-b'a'*1024]` | 2.387664162249834e-05 | 2.2220958262310435e-05 | 6.93% | 7.45% | 1.07x | ✅ | +| `hexbytes_getitem_index[5-long alternating]` | 2.3447450794083876e-05 | 2.2117716532324473e-05 | 5.67% | 6.01% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-mixed pattern]` | 2.3858675352130537e-05 | 2.237369899823486e-05 | 6.22% | 6.64% | 1.07x | ✅ | +| `hexbytes_getitem_index[5-multiples of 0x10]` | 2.3441867659560046e-05 | 2.204999308430266e-05 | 5.94% | 6.31% | 1.06x | ✅ | +| `hexbytes_getitem_index[5-palindrome ascii]` | 2.3958043445209287e-05 | 2.2279548089798347e-05 | 7.01% | 7.53% | 1.08x | ✅ | +| `hexbytes_getitem_index[5-palindrome]` | 2.370622874194218e-05 | 2.2535518141703165e-05 | 4.94% | 5.19% | 1.05x | ✅ | +| `hexbytes_getitem_index[5-repeated 0-9]` | 2.401607357845209e-05 | 2.2335016478901267e-05 | 7.00% | 7.53% | 1.08x | ✅ | +| `hexbytes_getitem_index[5-two patterns]` | 2.384207955910319e-05 | 2.2819046333930514e-05 | 4.29% | 4.48% | 1.04x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-0-9]` | 8.068234990254468e-05 | 5.9908517862950774e-05 | 25.75% | 34.68% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-4-byte pattern]` | 8.11249058632316e-05 | 5.914985501307563e-05 | 27.09% | 37.15% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-all byte values]` | 8.09292051944004e-05 | 5.996926055642412e-05 | 25.90% | 34.95% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-alternating 0x00/0xff]` | 8.050372644893333e-05 | 5.9492500278013574e-05 | 26.10% | 35.32% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-alternating 0xaa/0x55]` | 8.160105677786958e-05 | 5.9768697206212395e-05 | 26.75% | 36.53% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-ascii sentence]` | 8.059944833324778e-05 | 6.0538737184844244e-05 | 24.89% | 33.14% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'']` | 7.879725653296983e-05 | 5.773333058399736e-05 | 26.73% | 36.48% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x00'*32]` | 8.065340013430995e-05 | 5.992783206681132e-05 | 25.70% | 34.58% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x00\\xff\\x00\\xff']` | 8.110106993329847e-05 | 6.036323340154663e-05 | 25.57% | 34.36% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01'*100]` | 8.112706850935604e-05 | 5.985948007817502e-05 | 26.22% | 35.53% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01'*2048]` | 8.147721111379799e-05 | 6.052596027497756e-05 | 25.71% | 34.62% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01\\x02\\x03']` | 8.167215920607164e-05 | 6.009837985140856e-05 | 26.42% | 35.90% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.114676602016646e-05 | 6.013714140361474e-05 | 25.89% | 34.94% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x7f'*8]` | 8.158437482314103e-05 | 5.9964215072264316e-05 | 26.50% | 36.06% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\x80'*8]` | 8.11956405283511e-05 | 6.012798039697782e-05 | 25.95% | 35.04% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\xde\\xad\\xbe\\xef']` | 8.133062109897846e-05 | 6.0024769901838476e-05 | 26.20% | 35.50% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'\\xff'*64]` | 8.147021273208189e-05 | 6.014110090091815e-05 | 26.18% | 35.47% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'a'*1024]` | 8.184092645393188e-05 | 5.9690798562356445e-05 | 27.06% | 37.11% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-b'abc']` | 8.11407611580561e-05 | 6.0269786530966417e-05 | 25.72% | 34.63% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-long alternating]` | 8.138515989132823e-05 | 6.0051330791540194e-05 | 26.21% | 35.53% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-mixed pattern]` | 8.11307849411989e-05 | 5.948433203317993e-05 | 26.68% | 36.39% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-multiples of 0x10]` | 8.0865044025069e-05 | 6.067042211538623e-05 | 24.97% | 33.29% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-palindrome ascii]` | 8.098974116830668e-05 | 5.946342412898394e-05 | 26.58% | 36.20% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-palindrome numeric]` | 8.30720497246577e-05 | 5.996928553820368e-05 | 27.81% | 38.52% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-palindrome]` | 8.052636510236694e-05 | 6.009066007473859e-05 | 25.38% | 34.01% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-repeated 0-9]` | 8.17800832421859e-05 | 5.937056592499519e-05 | 27.40% | 37.75% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-single 0xff]` | 7.866251040166223e-05 | 5.7545369679967186e-05 | 26.85% | 36.70% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-single null byte]` | 7.89915242249266e-05 | 5.753772649427693e-05 | 27.16% | 37.29% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(-3,None)-two patterns]` | 8.080403866485248e-05 | 5.922889017319143e-05 | 26.70% | 36.43% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-0-9]` | 8.2622325636055e-05 | 6.0528968239167615e-05 | 26.74% | 36.50% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-4-byte pattern]` | 8.272651418364963e-05 | 6.092795295403125e-05 | 26.35% | 35.78% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-all byte values]` | 8.255031829407812e-05 | 6.0791886106560145e-05 | 26.36% | 35.79% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-alternating 0x00/0xff]` | 8.21723996281765e-05 | 6.0797497703534535e-05 | 26.01% | 35.16% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-alternating 0xaa/0x55]` | 8.221975981903979e-05 | 6.072751465186438e-05 | 26.14% | 35.39% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-ascii sentence]` | 8.367206394174686e-05 | 6.133230997235685e-05 | 26.70% | 36.42% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'']` | 8.06918569884131e-05 | 5.772912687932482e-05 | 28.46% | 39.78% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x00'*32]` | 8.266038445917815e-05 | 6.0560119980356125e-05 | 26.74% | 36.49% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x00\\xff\\x00\\xff']` | 8.20339136045329e-05 | 6.0075424777740126e-05 | 26.77% | 36.55% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x01'*100]` | 8.217707354153222e-05 | 6.054433994945807e-05 | 26.32% | 35.73% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x01'*2048]` | 8.258134725819903e-05 | 6.037501951340134e-05 | 26.89% | 36.78% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x01\\x02\\x03']` | 8.256973994855508e-05 | 6.028594637574512e-05 | 26.99% | 36.96% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.248224031876366e-05 | 6.0332711841273715e-05 | 26.85% | 36.71% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x7f'*8]` | 8.179846849894452e-05 | 6.092441941098647e-05 | 25.52% | 34.26% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\x80'*8]` | 8.186628293610639e-05 | 6.0235752841171e-05 | 26.42% | 35.91% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\xde\\xad\\xbe\\xef']` | 8.092846841651972e-05 | 6.04425395196323e-05 | 25.31% | 33.89% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'\\xff'*64]` | 8.124670067572987e-05 | 6.041566846002542e-05 | 25.64% | 34.48% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'a'*1024]` | 8.175597454964947e-05 | 6.06864513192614e-05 | 25.77% | 34.72% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-b'abc']` | 8.198075665936462e-05 | 6.0627726194316385e-05 | 26.05% | 35.22% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-long alternating]` | 8.204332835156302e-05 | 6.07988550706465e-05 | 25.89% | 34.94% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-mixed pattern]` | 8.17248904408768e-05 | 6.108961798914236e-05 | 25.25% | 33.78% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-multiples of 0x10]` | 8.291109128917191e-05 | 6.126453753386428e-05 | 26.11% | 35.33% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-palindrome ascii]` | 8.302702215551893e-05 | 6.0712845747646644e-05 | 26.88% | 36.75% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-palindrome numeric]` | 8.24454859497045e-05 | 6.0612859259637294e-05 | 26.48% | 36.02% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-palindrome]` | 8.080784793291502e-05 | 6.0116598701386324e-05 | 25.61% | 34.42% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-repeated 0-9]` | 8.334414217224779e-05 | 5.999776415961464e-05 | 28.01% | 38.91% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-single 0xff]` | 8.156183284693949e-05 | 5.931348806830272e-05 | 27.28% | 37.51% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-single null byte]` | 8.174356108905515e-05 | 5.900020044260341e-05 | 27.82% | 38.55% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(0,3)-two patterns]` | 8.22219209418392e-05 | 6.084418406394616e-05 | 26.00% | 35.14% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-0-9]` | 8.313658701170756e-05 | 5.895483225067839e-05 | 29.09% | 41.02% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-4-byte pattern]` | 8.196193234840055e-05 | 5.9606213484058697e-05 | 27.28% | 37.51% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-all byte values]` | 8.346399715113727e-05 | 6.023051273376708e-05 | 27.84% | 38.57% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-alternating 0x00/0xff]` | 8.179198156866263e-05 | 6.016420690452284e-05 | 26.44% | 35.95% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-alternating 0xaa/0x55]` | 8.163817929710001e-05 | 5.9934526712899444e-05 | 26.59% | 36.21% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-ascii sentence]` | 8.209272865155255e-05 | 6.092703580256333e-05 | 25.78% | 34.74% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'']` | 8.027790615778153e-05 | 5.7995641927442527e-05 | 27.76% | 38.42% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x00'*32]` | 8.276872109450775e-05 | 6.056089253842826e-05 | 26.83% | 36.67% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x00\\xff\\x00\\xff']` | 8.19567980550223e-05 | 5.9205196348911915e-05 | 27.76% | 38.43% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x01'*100]` | 8.313834030044157e-05 | 6.092565019477837e-05 | 26.72% | 36.46% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x01'*2048]` | 8.246281656146155e-05 | 5.975929586280049e-05 | 27.53% | 37.99% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x01\\x02\\x03']` | 8.199072701858649e-05 | 5.940088034279834e-05 | 27.55% | 38.03% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.258274406057332e-05 | 6.110407110891471e-05 | 26.01% | 35.15% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x7f'*8]` | 8.206723002467621e-05 | 6.056757308507195e-05 | 26.20% | 35.50% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\x80'*8]` | 8.208912763807277e-05 | 6.06431315458422e-05 | 26.13% | 35.36% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\xde\\xad\\xbe\\xef']` | 8.281438339446592e-05 | 5.9749517630166066e-05 | 27.85% | 38.60% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'\\xff'*64]` | 8.281844606293529e-05 | 5.9608617469888645e-05 | 28.02% | 38.94% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'a'*1024]` | 8.233301537469728e-05 | 5.9421223063502564e-05 | 27.83% | 38.56% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-b'abc']` | 8.317798982465156e-05 | 6.0510199715760295e-05 | 27.25% | 37.46% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-long alternating]` | 8.177884355440976e-05 | 5.960249797801825e-05 | 27.12% | 37.21% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-mixed pattern]` | 8.153793358950345e-05 | 6.058071977552699e-05 | 25.70% | 34.59% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-multiples of 0x10]` | 8.248096552844894e-05 | 5.9685025348125585e-05 | 27.64% | 38.19% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-palindrome ascii]` | 8.139138326813279e-05 | 6.119322011840429e-05 | 24.82% | 33.01% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-palindrome numeric]` | 8.14961322142407e-05 | 6.135827801269117e-05 | 24.71% | 32.82% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-palindrome]` | 8.155820494943751e-05 | 6.018801583839876e-05 | 26.20% | 35.51% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-repeated 0-9]` | 8.264213345195723e-05 | 6.0417248049566416e-05 | 26.89% | 36.79% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-single 0xff]` | 8.023151070244493e-05 | 5.7594480021759474e-05 | 28.21% | 39.30% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-single null byte]` | 8.018753225122147e-05 | 5.765371340802396e-05 | 28.10% | 39.08% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(1,6)-two patterns]` | 8.131570729214625e-05 | 6.049279725871943e-05 | 25.61% | 34.42% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-0-9]` | 8.14121963052695e-05 | 6.018746420393172e-05 | 26.07% | 35.26% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-4-byte pattern]` | 8.240409685413533e-05 | 6.081408245115794e-05 | 26.20% | 35.50% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-all byte values]` | 8.202717933675196e-05 | 6.065021454450571e-05 | 26.06% | 35.25% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-alternating 0x00/0xff]` | 8.2030339885261e-05 | 6.0688604341073643e-05 | 26.02% | 35.17% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-alternating 0xaa/0x55]` | 8.191594718237171e-05 | 6.068378042598657e-05 | 25.92% | 34.99% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-ascii sentence]` | 8.218106248410972e-05 | 6.071176547484893e-05 | 26.12% | 35.36% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'']` | 7.846717309544713e-05 | 5.731748541262407e-05 | 26.95% | 36.90% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x00'*32]` | 8.171215331135617e-05 | 6.049818370995403e-05 | 25.96% | 35.07% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x00\\xff\\x00\\xff']` | 8.008490774949858e-05 | 6.003003665949191e-05 | 25.04% | 33.41% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x01'*100]` | 8.170876382529361e-05 | 6.096559520721099e-05 | 25.39% | 34.02% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x01'*2048]` | 0.00010476437791326655 | 7.746346799212244e-05 | 26.06% | 35.24% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x01\\x02\\x03']` | 7.960454609000436e-05 | 5.7623088750788484e-05 | 27.61% | 38.15% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.107940673613911e-05 | 6.017446222218925e-05 | 25.78% | 34.74% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x7f'*8]` | 8.179921890396522e-05 | 6.0127637423181724e-05 | 26.49% | 36.04% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\x80'*8]` | 8.094503061559896e-05 | 6.033906979829822e-05 | 25.46% | 34.15% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\xde\\xad\\xbe\\xef']` | 8.2657600133284e-05 | 6.065080339822555e-05 | 26.62% | 36.28% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'\\xff'*64]` | 8.194716225175662e-05 | 6.017795967458637e-05 | 26.56% | 36.17% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'a'*1024]` | 9.693064215296854e-05 | 7.569989005474179e-05 | 21.90% | 28.05% | 1.28x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-b'abc']` | 7.912194866352589e-05 | 5.7795536500223504e-05 | 26.95% | 36.90% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-long alternating]` | 0.00010049567496632814 | 7.225055857475158e-05 | 28.11% | 39.09% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-mixed pattern]` | 8.21531364470839e-05 | 6.0966463356750096e-05 | 25.79% | 34.75% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-multiples of 0x10]` | 8.182128273575786e-05 | 5.950911816715105e-05 | 27.27% | 37.49% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-palindrome ascii]` | 8.173102597293032e-05 | 6.0450363378619016e-05 | 26.04% | 35.20% | 1.35x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-palindrome numeric]` | 8.064481667943535e-05 | 6.005529660558877e-05 | 25.53% | 34.28% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-palindrome]` | 8.146838256348088e-05 | 5.930252168165231e-05 | 27.21% | 37.38% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-repeated 0-9]` | 8.158039589364289e-05 | 6.068757436283316e-05 | 25.61% | 34.43% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-single 0xff]` | 7.892234626219822e-05 | 5.709236282816077e-05 | 27.66% | 38.24% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-single null byte]` | 7.835202393129527e-05 | 5.734935938542202e-05 | 26.81% | 36.62% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(2,None)-two patterns]` | 8.124228911371968e-05 | 6.0960659161912064e-05 | 24.96% | 33.27% | 1.33x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-0-9]` | 7.9430356937195e-05 | 5.75138086086997e-05 | 27.59% | 38.11% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-4-byte pattern]` | 8.083538128638625e-05 | 5.862082945179073e-05 | 27.48% | 37.90% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-all byte values]` | 8.060951725703728e-05 | 5.933151936678779e-05 | 26.40% | 35.86% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-alternating 0x00/0xff]` | 7.999629243724944e-05 | 5.763557713639643e-05 | 27.95% | 38.80% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-alternating 0xaa/0x55]` | 8.02130539314506e-05 | 5.7282829826576e-05 | 28.59% | 40.03% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-ascii sentence]` | 8.022463458559608e-05 | 5.9020510442109744e-05 | 26.43% | 35.93% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'']` | 7.71061669046454e-05 | 5.565648922236641e-05 | 27.82% | 38.54% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x00'*32]` | 8.090211399786762e-05 | 5.926002974818658e-05 | 26.75% | 36.52% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x00\\xff\\x00\\xff']` | 8.099782549973611e-05 | 5.8727517655832474e-05 | 27.49% | 37.92% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x01'*100]` | 8.115939604376683e-05 | 5.710263988029543e-05 | 29.64% | 42.13% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x01'*2048]` | 0.00010146242689006956 | 7.806360940270111e-05 | 23.06% | 29.97% | 1.30x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x01\\x02\\x03']` | 8.020230350063798e-05 | 5.804965471422574e-05 | 27.62% | 38.16% | 1.38x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 7.97868648430571e-05 | 5.6351813911057925e-05 | 29.37% | 41.59% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x7f'*8]` | 7.975691366162501e-05 | 5.600672332160979e-05 | 29.78% | 42.41% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\x80'*8]` | 7.945457643561741e-05 | 5.638943533155044e-05 | 29.03% | 40.90% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\xde\\xad\\xbe\\xef']` | 7.999624765962864e-05 | 5.88580201326653e-05 | 26.42% | 35.91% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'\\xff'*64]` | 8.017778856891062e-05 | 5.9135237732123635e-05 | 26.24% | 35.58% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'a'*1024]` | 9.863015309092291e-05 | 6.957885123547411e-05 | 29.45% | 41.75% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-b'abc']` | 8.043158298894438e-05 | 5.794496088357798e-05 | 27.96% | 38.81% | 1.39x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-long alternating]` | 9.52467992574056e-05 | 7.340333486803448e-05 | 22.93% | 29.76% | 1.30x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-mixed pattern]` | 8.073709406148429e-05 | 5.952576523301626e-05 | 26.27% | 35.63% | 1.36x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-multiples of 0x10]` | 7.976009010096381e-05 | 5.6305954230380405e-05 | 29.41% | 41.65% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-palindrome ascii]` | 7.920245338866143e-05 | 5.763644401517949e-05 | 27.23% | 37.42% | 1.37x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-palindrome numeric]` | 7.9939929537322e-05 | 5.7125410998791315e-05 | 28.54% | 39.94% | 1.40x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-palindrome]` | 8.016544171041521e-05 | 5.551693119839742e-05 | 30.75% | 44.40% | 1.44x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-repeated 0-9]` | 8.068510058369967e-05 | 6.0166740150958995e-05 | 25.43% | 34.10% | 1.34x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-single 0xff]` | 7.804954601624467e-05 | 5.506197227846088e-05 | 29.45% | 41.75% | 1.42x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-single null byte]` | 7.816215323890064e-05 | 5.5627027377838706e-05 | 28.83% | 40.51% | 1.41x | ✅ | +| `hexbytes_getitem_slice[slice(None,None)-two patterns]` | 8.071645942788979e-05 | 5.934724027483824e-05 | 26.47% | 36.01% | 1.36x | ✅ | +| `hexbytes_new['']` | 7.059339453681849e-05 | 3.720572167745306e-05 | 47.30% | 89.74% | 1.90x | ✅ | +| `hexbytes_new['0x'+'00'*64]` | 9.185311650414212e-05 | 4.9458678953195796e-05 | 46.15% | 85.72% | 1.86x | ✅ | +| `hexbytes_new['0x'+'a'*128]` | 9.184894177237468e-05 | 5.104373326869315e-05 | 44.43% | 79.94% | 1.80x | ✅ | +| `hexbytes_new['0x'+'ff'*32]` | 8.88221703346839e-05 | 4.645459160491125e-05 | 47.70% | 91.20% | 1.91x | ✅ | +| `hexbytes_new['0x']` | 7.839122044398893e-05 | 3.842018705163114e-05 | 50.99% | 104.04% | 2.04x | ✅ | +| `hexbytes_new['0x1234']` | 8.604767258883253e-05 | 4.458978211603869e-05 | 48.18% | 92.98% | 1.93x | ✅ | +| `hexbytes_new['0xCAFEBABE']` | 8.569109342851317e-05 | 4.365468820511476e-05 | 49.06% | 96.29% | 1.96x | ✅ | +| `hexbytes_new['0xabcdef']` | 8.593088756520804e-05 | 4.45373277594925e-05 | 48.17% | 92.94% | 1.93x | ✅ | +| `hexbytes_new['0xdeadbeef']` | 8.627125497488135e-05 | 4.442037623583596e-05 | 48.51% | 94.22% | 1.94x | ✅ | +| `hexbytes_new['abc']` | 8.213154539849242e-05 | 4.7106935923321183e-05 | 42.64% | 74.35% | 1.74x | ✅ | +| `hexbytes_new['deadbeef']` | 7.619061738594097e-05 | 4.1301610026598785e-05 | 45.79% | 84.47% | 1.84x | ✅ | +| `hexbytes_new[0-9]` | 4.295882153627664e-05 | 2.5316265129541266e-05 | 41.07% | 69.69% | 1.70x | ✅ | +| `hexbytes_new[0]` | 0.00012231687726766509 | 6.0478503253778025e-05 | 50.56% | 102.25% | 2.02x | ✅ | +| `hexbytes_new[123456]` | 0.0001266123322099141 | 6.583570512732421e-05 | 48.00% | 92.32% | 1.92x | ✅ | +| `hexbytes_new[2**16]` | 0.00012774508225165453 | 6.617318450917904e-05 | 48.20% | 93.05% | 1.93x | ✅ | +| `hexbytes_new[2**256-1]` | 0.00013121266143061903 | 7.351050389468393e-05 | 43.98% | 78.50% | 1.78x | ✅ | +| `hexbytes_new[2**32]` | 0.00013085130021646147 | 6.981460054531131e-05 | 46.65% | 87.43% | 1.87x | ✅ | +| `hexbytes_new[2**64]` | 0.0001324229245798965 | 7.127814146942154e-05 | 46.17% | 85.78% | 1.86x | ✅ | +| `hexbytes_new[2**8]` | 0.00012605911740696366 | 6.3048691085867e-05 | 49.98% | 99.94% | 2.00x | ✅ | +| `hexbytes_new[4-byte pattern]` | 4.295112867205666e-05 | 2.7806419556598662e-05 | 35.26% | 54.46% | 1.54x | ✅ | +| `hexbytes_new[False]` | 6.087290743084603e-05 | 2.6771864289568586e-05 | 56.02% | 127.38% | 2.27x | ✅ | +| `hexbytes_new[True]` | 6.088600700348238e-05 | 2.696853017901539e-05 | 55.71% | 125.77% | 2.26x | ✅ | +| `hexbytes_new[all byte values]` | 4.333466030390133e-05 | 2.7894081810705685e-05 | 35.63% | 55.35% | 1.55x | ✅ | +| `hexbytes_new[alternating 0x00/0xff]` | 4.287333638228319e-05 | 2.594063403652535e-05 | 39.49% | 65.27% | 1.65x | ✅ | +| `hexbytes_new[alternating 0xaa/0x55]` | 4.273885980923265e-05 | 2.5827765223145366e-05 | 39.57% | 65.48% | 1.65x | ✅ | +| `hexbytes_new[ascii sentence]` | 4.313410983817353e-05 | 2.546554532135807e-05 | 40.96% | 69.38% | 1.69x | ✅ | +| `hexbytes_new[b'']` | 4.1701536417217834e-05 | 2.5443427864218587e-05 | 38.99% | 63.90% | 1.64x | ✅ | +| `hexbytes_new[b'\\x00'*32]` | 4.2708400224018625e-05 | 2.531691282877622e-05 | 40.72% | 68.70% | 1.69x | ✅ | +| `hexbytes_new[b'\\x00\\xff\\x00\\xff']` | 4.2081834338195306e-05 | 2.5464436144364045e-05 | 39.49% | 65.26% | 1.65x | ✅ | +| `hexbytes_new[b'\\x01'*100]` | 4.387343088107201e-05 | 2.6034466974391452e-05 | 40.66% | 68.52% | 1.69x | ✅ | +| `hexbytes_new[b'\\x01'*2048]` | 5.733198446675121e-05 | 3.879941616922359e-05 | 32.33% | 47.77% | 1.48x | ✅ | +| `hexbytes_new[b'\\x01\\x02\\x03']` | 4.2723619263841565e-05 | 2.5355395989687225e-05 | 40.65% | 68.50% | 1.68x | ✅ | +| `hexbytes_new[b'\\x10\\x20\\x30\\x40\\x50']` | 4.224746088317716e-05 | 2.528448930199794e-05 | 40.15% | 67.09% | 1.67x | ✅ | +| `hexbytes_new[b'\\x7f'*8]` | 4.213323056509161e-05 | 2.4986245013606142e-05 | 40.70% | 68.63% | 1.69x | ✅ | +| `hexbytes_new[b'\\x80'*8]` | 4.2536395501683135e-05 | 2.5072862766728953e-05 | 41.06% | 69.65% | 1.70x | ✅ | +| `hexbytes_new[b'\\xde\\xad\\xbe\\xef']` | 4.2394029725542104e-05 | 2.540955404834232e-05 | 40.06% | 66.84% | 1.67x | ✅ | +| `hexbytes_new[b'\\xff'*64]` | 4.261945097059883e-05 | 2.587775309265785e-05 | 39.28% | 64.70% | 1.65x | ✅ | +| `hexbytes_new[b'a'*1024]` | 5.133675556752819e-05 | 3.3138708548557765e-05 | 35.45% | 54.91% | 1.55x | ✅ | +| `hexbytes_new[b'abc']` | 4.2674347397571076e-05 | 2.5163975539327663e-05 | 41.03% | 69.59% | 1.70x | ✅ | +| `hexbytes_new[bytearray(0-9)]` | 6.865169676977511e-05 | 3.7259202139075596e-05 | 45.73% | 84.25% | 1.84x | ✅ | +| `hexbytes_new[bytearray(4-byte pattern)]` | 6.953209316813137e-05 | 3.816708106647471e-05 | 45.11% | 82.18% | 1.82x | ✅ | +| `hexbytes_new[bytearray(all byte values)]` | 6.898457893830663e-05 | 3.8168352788462077e-05 | 44.67% | 80.74% | 1.81x | ✅ | +| `hexbytes_new[bytearray(alternating 0x00/0xff)]` | 6.908631410366376e-05 | 3.778673334190037e-05 | 45.31% | 82.83% | 1.83x | ✅ | +| `hexbytes_new[bytearray(alternating 0xaa/0x55)]` | 6.845419039658357e-05 | 3.777392923671646e-05 | 44.82% | 81.22% | 1.81x | ✅ | +| `hexbytes_new[bytearray(ascii sentence)]` | 6.972701953861159e-05 | 3.732977678561211e-05 | 46.46% | 86.79% | 1.87x | ✅ | +| `hexbytes_new[bytearray(b'')]` | 6.678502978133552e-05 | 3.561588238570766e-05 | 46.67% | 87.51% | 1.88x | ✅ | +| `hexbytes_new[bytearray(b'\\x00'*32)]` | 6.932840331862772e-05 | 3.722964287143302e-05 | 46.30% | 86.22% | 1.86x | ✅ | +| `hexbytes_new[bytearray(b'\\x00\\xff\\x00\\xff')]` | 6.955368340544366e-05 | 4.051862445406872e-05 | 41.74% | 71.66% | 1.72x | ✅ | +| `hexbytes_new[bytearray(b'\\x01'*100)]` | 6.929357571310845e-05 | 3.8765838753758206e-05 | 44.06% | 78.75% | 1.79x | ✅ | +| `hexbytes_new[bytearray(b'\\x01'*2048)]` | 9.350162891314769e-05 | 5.560644346862349e-05 | 40.53% | 68.15% | 1.68x | ✅ | +| `hexbytes_new[bytearray(b'\\x01\\x02\\x03')]` | 6.935026736671355e-05 | 3.845283974606172e-05 | 44.55% | 80.35% | 1.80x | ✅ | +| `hexbytes_new[bytearray(b'\\x10\\x20\\x30\\x40\\x50')]` | 6.868295439875171e-05 | 3.880361048641301e-05 | 43.50% | 77.00% | 1.77x | ✅ | +| `hexbytes_new[bytearray(b'\\x7f'*8)]` | 6.8469512349617e-05 | 3.72148175217809e-05 | 45.65% | 83.98% | 1.84x | ✅ | +| `hexbytes_new[bytearray(b'\\x80'*8)]` | 6.842226934820798e-05 | 3.7711169514167804e-05 | 44.88% | 81.44% | 1.81x | ✅ | +| `hexbytes_new[bytearray(b'\\xde\\xad\\xbe\\xef')]` | 6.90195149679681e-05 | 3.838316011293737e-05 | 44.39% | 79.82% | 1.80x | ✅ | +| `hexbytes_new[bytearray(b'\\xff'*64)]` | 6.919485734372232e-05 | 3.7846437835231215e-05 | 45.30% | 82.83% | 1.83x | ✅ | +| `hexbytes_new[bytearray(b'a'*1024)]` | 8.567915298868023e-05 | 5.015077982644348e-05 | 41.47% | 70.84% | 1.71x | ✅ | +| `hexbytes_new[bytearray(b'abc')]` | 6.9138375339417e-05 | 3.831013846730171e-05 | 44.59% | 80.47% | 1.80x | ✅ | +| `hexbytes_new[bytearray(long alternating)]` | 8.756419426149756e-05 | 4.940683158110184e-05 | 43.58% | 77.23% | 1.77x | ✅ | +| `hexbytes_new[bytearray(mixed pattern)]` | 6.93203185786192e-05 | 3.906978385134366e-05 | 43.64% | 77.43% | 1.77x | ✅ | +| `hexbytes_new[bytearray(multiples of 0x10)]` | 6.887247167193475e-05 | 3.7106534309345784e-05 | 46.12% | 85.61% | 1.86x | ✅ | +| `hexbytes_new[bytearray(palindrome ascii)]` | 6.746962549895354e-05 | 3.7175894460748066e-05 | 44.90% | 81.49% | 1.81x | ✅ | +| `hexbytes_new[bytearray(palindrome numeric)]` | 6.869543028529821e-05 | 3.81874595499812e-05 | 44.41% | 79.89% | 1.80x | ✅ | +| `hexbytes_new[bytearray(palindrome)]` | 6.868747138894986e-05 | 3.733346010256775e-05 | 45.65% | 83.98% | 1.84x | ✅ | +| `hexbytes_new[bytearray(repeated 0-9)]` | 6.911508148086022e-05 | 3.761974277890361e-05 | 45.57% | 83.72% | 1.84x | ✅ | +| `hexbytes_new[bytearray(single 0xff)]` | 6.969344641567276e-05 | 3.821283515052185e-05 | 45.17% | 82.38% | 1.82x | ✅ | +| `hexbytes_new[bytearray(single null byte)]` | 6.8821272252622e-05 | 3.81009238681271e-05 | 44.64% | 80.63% | 1.81x | ✅ | +| `hexbytes_new[bytearray(two patterns)]` | 6.947249127955981e-05 | 3.830322091851254e-05 | 44.87% | 81.38% | 1.81x | ✅ | +| `hexbytes_new[long alternating]` | 5.160353372444581e-05 | 3.319370597996107e-05 | 35.68% | 55.46% | 1.55x | ✅ | +| `hexbytes_new[memoryview(0-9)]` | 8.402488421221348e-05 | 4.305165841161287e-05 | 48.76% | 95.17% | 1.95x | ✅ | +| `hexbytes_new[memoryview(4-byte pattern)]` | 8.483368913519236e-05 | 4.420043890266264e-05 | 47.90% | 91.93% | 1.92x | ✅ | +| `hexbytes_new[memoryview(all byte values)]` | 8.277553206819768e-05 | 4.437347169215945e-05 | 46.39% | 86.54% | 1.87x | ✅ | +| `hexbytes_new[memoryview(alternating 0x00/0xff)]` | 8.432842735782323e-05 | 4.3162543582832885e-05 | 48.82% | 95.37% | 1.95x | ✅ | +| `hexbytes_new[memoryview(alternating 0xaa/0x55)]` | 8.4226051455622e-05 | 4.2706406710533925e-05 | 49.30% | 97.22% | 1.97x | ✅ | +| `hexbytes_new[memoryview(ascii sentence)]` | 8.28974079227692e-05 | 4.2487380181126084e-05 | 48.75% | 95.11% | 1.95x | ✅ | +| `hexbytes_new[memoryview(b'')]` | 8.23962123283304e-05 | 4.025397220300485e-05 | 51.15% | 104.69% | 2.05x | ✅ | +| `hexbytes_new[memoryview(b'\\x00'*32)]` | 8.302596758787724e-05 | 4.27510432520547e-05 | 48.51% | 94.21% | 1.94x | ✅ | +| `hexbytes_new[memoryview(b'\\x00\\xff\\x00\\xff')]` | 8.356703476862896e-05 | 4.305663606365146e-05 | 48.48% | 94.09% | 1.94x | ✅ | +| `hexbytes_new[memoryview(b'\\x01'*100)]` | 8.392830503024734e-05 | 4.306008859209643e-05 | 48.69% | 94.91% | 1.95x | ✅ | +| `hexbytes_new[memoryview(b'\\x01'*2048)]` | 0.0001083133241625787 | 6.181063451514009e-05 | 42.93% | 75.23% | 1.75x | ✅ | +| `hexbytes_new[memoryview(b'\\x01\\x02\\x03')]` | 8.274879907228332e-05 | 4.235713144033117e-05 | 48.81% | 95.36% | 1.95x | ✅ | +| `hexbytes_new[memoryview(b'\\x10\\x20\\x30\\x40\\x50')]` | 8.341332207145342e-05 | 4.2522852834659024e-05 | 49.02% | 96.16% | 1.96x | ✅ | +| `hexbytes_new[memoryview(b'\\x7f'*8)]` | 8.277404148909936e-05 | 4.275480455433159e-05 | 48.35% | 93.60% | 1.94x | ✅ | +| `hexbytes_new[memoryview(b'\\x80'*8)]` | 8.32985845173698e-05 | 4.2725686219471154e-05 | 48.71% | 94.96% | 1.95x | ✅ | +| `hexbytes_new[memoryview(b'\\xde\\xad\\xbe\\xef')]` | 8.34094967409787e-05 | 4.253482172593846e-05 | 49.00% | 96.10% | 1.96x | ✅ | +| `hexbytes_new[memoryview(b'\\xff'*64)]` | 8.333514805646204e-05 | 4.2686659313615054e-05 | 48.78% | 95.23% | 1.95x | ✅ | +| `hexbytes_new[memoryview(b'a'*1024)]` | 9.924937529033548e-05 | 5.5952107027414155e-05 | 43.62% | 77.38% | 1.77x | ✅ | +| `hexbytes_new[memoryview(b'abc')]` | 8.35927274669656e-05 | 4.261450935855843e-05 | 49.02% | 96.16% | 1.96x | ✅ | +| `hexbytes_new[memoryview(long alternating)]` | 0.00010227541168152174 | 5.6218582273413e-05 | 45.03% | 81.92% | 1.82x | ✅ | +| `hexbytes_new[memoryview(mixed pattern)]` | 8.042701159791098e-05 | 4.298920272923132e-05 | 46.55% | 87.09% | 1.87x | ✅ | +| `hexbytes_new[memoryview(multiples of 0x10)]` | 8.40677904662531e-05 | 4.314210112540732e-05 | 48.68% | 94.86% | 1.95x | ✅ | +| `hexbytes_new[memoryview(palindrome ascii)]` | 8.324889707805461e-05 | 4.310495465835889e-05 | 48.22% | 93.13% | 1.93x | ✅ | +| `hexbytes_new[memoryview(palindrome numeric)]` | 8.343425922642345e-05 | 4.273448915555574e-05 | 48.78% | 95.24% | 1.95x | ✅ | +| `hexbytes_new[memoryview(palindrome)]` | 8.561975046176595e-05 | 4.265896393780081e-05 | 50.18% | 100.71% | 2.01x | ✅ | +| `hexbytes_new[memoryview(repeated 0-9)]` | 8.310467831977971e-05 | 4.3063931759602075e-05 | 48.18% | 92.98% | 1.93x | ✅ | +| `hexbytes_new[memoryview(single 0xff)]` | 8.320841623582506e-05 | 4.2339979937306514e-05 | 49.12% | 96.52% | 1.97x | ✅ | +| `hexbytes_new[memoryview(single null byte)]` | 8.366610652141289e-05 | 4.24293937974122e-05 | 49.29% | 97.19% | 1.97x | ✅ | +| `hexbytes_new[memoryview(two patterns)]` | 8.162854716979587e-05 | 4.3148312062757567e-05 | 47.14% | 89.18% | 1.89x | ✅ | +| `hexbytes_new[mixed pattern]` | 4.3233341128517325e-05 | 2.5983755841529144e-05 | 39.90% | 66.39% | 1.66x | ✅ | +| `hexbytes_new[multiples of 0x10]` | 4.453038188270421e-05 | 2.5264566840342406e-05 | 43.26% | 76.26% | 1.76x | ✅ | +| `hexbytes_new[palindrome ascii]` | 4.229629357318056e-05 | 2.5336603703738986e-05 | 40.10% | 66.94% | 1.67x | ✅ | +| `hexbytes_new[palindrome numeric]` | 4.272307948255706e-05 | 2.5146011528992055e-05 | 41.14% | 69.90% | 1.70x | ✅ | +| `hexbytes_new[palindrome]` | 4.201348902376135e-05 | 2.5233103985190362e-05 | 39.94% | 66.50% | 1.67x | ✅ | +| `hexbytes_new[repeated 0-9]` | 4.2849040366098236e-05 | 2.5941053878904493e-05 | 39.46% | 65.18% | 1.65x | ✅ | +| `hexbytes_new[single 0xff]` | 4.286213200795317e-05 | 2.492020956546657e-05 | 41.86% | 72.00% | 1.72x | ✅ | +| `hexbytes_new[single null byte]` | 4.192499090325599e-05 | 2.499780743653151e-05 | 40.37% | 67.71% | 1.68x | ✅ | +| `hexbytes_new[two patterns]` | 4.263737600661353e-05 | 2.5978849285802113e-05 | 39.07% | 64.12% | 1.64x | ✅ | +| `hexbytes_repr[0-9]` | 2.8906603901256988e-05 | 4.826409864705047e-05 | -66.97% | -40.11% | 0.60x | ❌ | +| `hexbytes_repr[4-byte pattern]` | 0.00011963341642583751 | 0.0001400665401070896 | -17.08% | -14.59% | 0.85x | ❌ | +| `hexbytes_repr[all byte values]` | 0.00011982235283705905 | 0.00013990902582604605 | -16.76% | -14.36% | 0.86x | ❌ | +| `hexbytes_repr[alternating 0x00/0xff]` | 4.856278231022973e-05 | 6.823805107868716e-05 | -40.52% | -28.83% | 0.71x | ❌ | +| `hexbytes_repr[alternating 0xaa/0x55]` | 4.857590398733753e-05 | 6.995288404312158e-05 | -44.01% | -30.56% | 0.69x | ❌ | +| `hexbytes_repr[ascii sentence]` | 4.031931849084338e-05 | 5.950601363909072e-05 | -47.59% | -32.24% | 0.68x | ❌ | +| `hexbytes_repr[b'']` | 2.1317235451217533e-05 | 3.9220457560879214e-05 | -83.98% | -45.65% | 0.54x | ❌ | +| `hexbytes_repr[b'\\x00'*32]` | 3.6531415565533604e-05 | 5.550275792589815e-05 | -51.93% | -34.18% | 0.66x | ❌ | +| `hexbytes_repr[b'\\x00\\xff\\x00\\xff']` | 2.637317037783945e-05 | 4.5718566832638076e-05 | -73.35% | -42.31% | 0.58x | ❌ | +| `hexbytes_repr[b'\\x01'*100]` | 6.088965111409175e-05 | 8.061184262466249e-05 | -32.39% | -24.47% | 0.76x | ❌ | +| `hexbytes_repr[b'\\x01'*2048]` | 0.0007614258905273656 | 0.0007861038751990369 | -3.24% | -3.14% | 0.97x | ❌ | +| `hexbytes_repr[b'\\x01\\x02\\x03']` | 2.6209223833763088e-05 | 4.54939655277082e-05 | -73.58% | -42.39% | 0.58x | ❌ | +| `hexbytes_repr[b'\\x10\\x20\\x30\\x40\\x50']` | 2.7028655231277712e-05 | 4.619027613384838e-05 | -70.89% | -41.48% | 0.59x | ❌ | +| `hexbytes_repr[b'\\x7f'*8]` | 2.8230645154587657e-05 | 4.904206182181031e-05 | -73.72% | -42.44% | 0.58x | ❌ | +| `hexbytes_repr[b'\\x80'*8]` | 2.8426131680960446e-05 | 4.777460813929573e-05 | -68.07% | -40.50% | 0.60x | ❌ | +| `hexbytes_repr[b'\\xde\\xad\\xbe\\xef']` | 2.6337729088802863e-05 | 4.547637607019854e-05 | -72.67% | -42.08% | 0.58x | ❌ | +| `hexbytes_repr[b'\\xff'*64]` | 4.864470126407969e-05 | 6.820290034013081e-05 | -40.21% | -28.68% | 0.71x | ❌ | +| `hexbytes_repr[b'a'*1024]` | 0.0003943152236865464 | 0.0004167634849109744 | -5.69% | -5.39% | 0.95x | ❌ | +| `hexbytes_repr[b'abc']` | 2.6066297462518963e-05 | 4.519746535806044e-05 | -73.39% | -42.33% | 0.58x | ❌ | +| `hexbytes_repr[long alternating]` | 0.00039789659825941614 | 0.00041966943296914243 | -5.47% | -5.19% | 0.95x | ❌ | +| `hexbytes_repr[mixed pattern]` | 9.750328166691435e-05 | 0.00011687490478363051 | -19.87% | -16.57% | 0.83x | ❌ | +| `hexbytes_repr[multiples of 0x10]` | 2.8799433607726066e-05 | 4.825756547722914e-05 | -67.56% | -40.32% | 0.60x | ❌ | +| `hexbytes_repr[palindrome ascii]` | 2.7796805953080366e-05 | 4.6697563483038906e-05 | -68.00% | -40.47% | 0.60x | ❌ | +| `hexbytes_repr[palindrome numeric]` | 2.7060029458088667e-05 | 4.60052916156726e-05 | -70.01% | -41.18% | 0.59x | ❌ | +| `hexbytes_repr[palindrome]` | 3.1699440174901834e-05 | 5.113128257544771e-05 | -61.30% | -38.00% | 0.62x | ❌ | +| `hexbytes_repr[repeated 0-9]` | 6.1059735802075e-05 | 8.09308274489489e-05 | -32.54% | -24.55% | 0.75x | ❌ | +| `hexbytes_repr[single 0xff]` | 2.5412433661322482e-05 | 4.4486854740555556e-05 | -75.06% | -42.88% | 0.57x | ❌ | +| `hexbytes_repr[single null byte]` | 2.571699182079626e-05 | 4.427370703012172e-05 | -72.16% | -41.91% | 0.58x | ❌ | +| `hexbytes_repr[two patterns]` | 4.8579280895801936e-05 | 6.850903517262255e-05 | -41.03% | -29.09% | 0.71x | ❌ | +| `hexbytes_to_0x_hex[0-9]` | 1.551396585047557e-05 | 1.3630300793019073e-05 | 12.14% | 13.82% | 1.14x | ✅ | +| `hexbytes_to_0x_hex[4-byte pattern]` | 4.195234456795008e-05 | 4.012706081221306e-05 | 4.35% | 4.55% | 1.05x | ✅ | +| `hexbytes_to_0x_hex[all byte values]` | 4.211303275401072e-05 | 4.028452591251296e-05 | 4.34% | 4.54% | 1.05x | ✅ | +| `hexbytes_to_0x_hex[alternating 0x00/0xff]` | 2.0800595554670752e-05 | 1.9010172893267305e-05 | 8.61% | 9.42% | 1.09x | ✅ | +| `hexbytes_to_0x_hex[alternating 0xaa/0x55]` | 2.0904581121842868e-05 | 1.9147459039671937e-05 | 8.41% | 9.18% | 1.09x | ✅ | +| `hexbytes_to_0x_hex[ascii sentence]` | 1.885077859672098e-05 | 1.7071625813539214e-05 | 9.44% | 10.42% | 1.10x | ✅ | +| `hexbytes_to_0x_hex[b'']` | 1.026480036137029e-05 | 1.1345847549565756e-05 | -10.53% | -9.53% | 0.90x | ❌ | +| `hexbytes_to_0x_hex[b'\\x00'*32]` | 1.7477926479293212e-05 | 1.583933858505862e-05 | 9.38% | 10.35% | 1.10x | ✅ | +| `hexbytes_to_0x_hex[b'\\x00\\xff\\x00\\xff']` | 1.5048574884238393e-05 | 1.3065242835046563e-05 | 13.18% | 15.18% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[b'\\x01'*100]` | 2.5080113367605668e-05 | 2.2536233916689552e-05 | 10.14% | 11.29% | 1.11x | ✅ | +| `hexbytes_to_0x_hex[b'\\x01'*2048]` | 0.00022120556912250792 | 0.0002211920219665213 | 0.01% | 0.01% | 1.00x | ✅ | +| `hexbytes_to_0x_hex[b'\\x01\\x02\\x03']` | 1.484649658669481e-05 | 1.3091211127426347e-05 | 11.82% | 13.41% | 1.13x | ✅ | +| `hexbytes_to_0x_hex[b'\\x10\\x20\\x30\\x40\\x50']` | 1.5047836277518734e-05 | 1.3107099760095945e-05 | 12.90% | 14.81% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[b'\\x7f'*8]` | 1.5407694127854997e-05 | 1.354045064787356e-05 | 12.12% | 13.79% | 1.14x | ✅ | +| `hexbytes_to_0x_hex[b'\\x80'*8]` | 1.5428943320727377e-05 | 1.3440175575873593e-05 | 12.89% | 14.80% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[b'\\xde\\xad\\xbe\\xef']` | 1.5012446645307307e-05 | 1.313473795929436e-05 | 12.51% | 14.30% | 1.14x | ✅ | +| `hexbytes_to_0x_hex[b'\\xff'*64]` | 2.0806946366311905e-05 | 1.92471000032091e-05 | 7.50% | 8.10% | 1.08x | ✅ | +| `hexbytes_to_0x_hex[b'a'*1024]` | 0.0001223788737133279 | 0.00011830648768577156 | 3.33% | 3.44% | 1.03x | ✅ | +| `hexbytes_to_0x_hex[b'abc']` | 1.5010069965050508e-05 | 1.3101622063792088e-05 | 12.71% | 14.57% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[long alternating]` | 0.00012198009534447016 | 0.00012121568938859308 | 0.63% | 0.63% | 1.01x | ✅ | +| `hexbytes_to_0x_hex[mixed pattern]` | 3.4878635442167046e-05 | 3.308848224624071e-05 | 5.13% | 5.41% | 1.05x | ✅ | +| `hexbytes_to_0x_hex[multiples of 0x10]` | 1.5537679378131247e-05 | 1.3550212089721784e-05 | 12.79% | 14.67% | 1.15x | ✅ | +| `hexbytes_to_0x_hex[palindrome ascii]` | 1.526067072378255e-05 | 1.3441697074053967e-05 | 11.92% | 13.53% | 1.14x | ✅ | +| `hexbytes_to_0x_hex[palindrome numeric]` | 1.4922041049843883e-05 | 1.3376076252462054e-05 | 10.36% | 11.56% | 1.12x | ✅ | +| `hexbytes_to_0x_hex[palindrome]` | 1.6556797581452576e-05 | 1.4670629146908296e-05 | 11.39% | 12.86% | 1.13x | ✅ | +| `hexbytes_to_0x_hex[repeated 0-9]` | 2.5101944937213006e-05 | 2.2453825049654264e-05 | 10.55% | 11.79% | 1.12x | ✅ | +| `hexbytes_to_0x_hex[single 0xff]` | 1.4652719088638188e-05 | 1.2820154930984992e-05 | 12.51% | 14.29% | 1.14x | ✅ | +| `hexbytes_to_0x_hex[single null byte]` | 1.4640124525707886e-05 | 1.2928737904935405e-05 | 11.69% | 13.24% | 1.13x | ✅ | +| `hexbytes_to_0x_hex[two patterns]` | 2.076404064230241e-05 | 1.8906706862571387e-05 | 8.94% | 9.82% | 1.10x | ✅ | From 78565ce75c06e6deaaedcb349142cd89fd0875d4 Mon Sep 17 00:00:00 2001 From: BobTheBuidler Date: Tue, 30 Sep 2025 09:10:16 +0000 Subject: [PATCH 46/70] black . --- benchmarks/params.py | 2 + benchmarks/test__utils_benchmarks.py | 11 +++++- benchmarks/test_main_benchmarks.py | 36 +++++++++++++---- .../benchmark/compare_benchmark_results.py | 10 +++-- .../benchmark/generate_benchmark_markdown.py | 39 +++++++++++++++---- setup.py | 11 +++++- 6 files changed, 88 insertions(+), 21 deletions(-) diff --git a/benchmarks/params.py b/benchmarks/params.py index 1f65047..7784144 100644 --- a/benchmarks/params.py +++ b/benchmarks/params.py @@ -42,9 +42,11 @@ 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") diff --git a/benchmarks/test__utils_benchmarks.py b/benchmarks/test__utils_benchmarks.py index d0a1c97..5049c14 100644 --- a/benchmarks/test__utils_benchmarks.py +++ b/benchmarks/test__utils_benchmarks.py @@ -7,29 +7,36 @@ import faster_hexbytes._utils from benchmarks.params import ( - TO_BYTES_VALS, TO_BYTES_IDS, - HEXSTRINGS, HEXSTRINGS_IDS, + 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: diff --git a/benchmarks/test_main_benchmarks.py b/benchmarks/test_main_benchmarks.py index 43143f4..0ed29c8 100644 --- a/benchmarks/test_main_benchmarks.py +++ b/benchmarks/test_main_benchmarks.py @@ -6,73 +6,95 @@ import faster_hexbytes from benchmarks.params import ( - CONSTRUCTOR_VALS, CONSTRUCTOR_IDS, - BYTES_VALS, BYTES_IDS, - SLICES, SLICE_IDS, + 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: +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: +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: +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: +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: diff --git a/scripts/benchmark/compare_benchmark_results.py b/scripts/benchmark/compare_benchmark_results.py index 5f5fa01..fbb9f2f 100644 --- a/scripts/benchmark/compare_benchmark_results.py +++ b/scripts/benchmark/compare_benchmark_results.py @@ -45,9 +45,13 @@ def compare_group(group_results: Dict[str, Any]) -> Dict[str, Any]: 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') + 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, diff --git a/scripts/benchmark/generate_benchmark_markdown.py b/scripts/benchmark/generate_benchmark_markdown.py index 3d3aed7..ea79168 100644 --- a/scripts/benchmark/generate_benchmark_markdown.py +++ b/scripts/benchmark/generate_benchmark_markdown.py @@ -1,6 +1,7 @@ import os import json + def main(): diff_path = "pytest_benchmark_diff.json" results_dir = os.path.join("benchmarks", "results") @@ -8,7 +9,9 @@ def main(): # 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/", "") + 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) @@ -19,7 +22,7 @@ def main(): benchmarkFile = "unknown" m = None if submodule.startswith("faster_hexbytes."): - m = submodule[len("faster_hexbytes."):] + m = submodule[len("faster_hexbytes.") :] if m: submoduleFile = f"faster_hexbytes/{m}.py" @@ -29,9 +32,15 @@ def main(): 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("|----------|---------------|-------------|----------|-------------|----------|--------|") + 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: @@ -40,9 +49,22 @@ def main(): 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 "" + 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} |" ) @@ -58,5 +80,6 @@ def main(): with open(out_path, "w", encoding="utf-8") as outf: outf.write(md_content) + if __name__ == "__main__": main() diff --git a/setup.py b/setup.py index 121043c..4df8ebe 100644 --- a/setup.py +++ b/setup.py @@ -68,7 +68,16 @@ license="MIT", zip_safe=False, keywords="ethereum", - packages=find_packages(exclude=["scripts", "scripts.*", "tests", "tests.*", "benchmarks", "benchmarks.*"]), + packages=find_packages( + exclude=[ + "scripts", + "scripts.*", + "tests", + "tests.*", + "benchmarks", + "benchmarks.*", + ] + ), ext_modules=ext_modules, package_data={"faster_hexbytes": ["py.typed"]}, classifiers=[ From 4da7ed01349c4bebf178eaf516517d9797105c9e Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 05:25:19 -0400 Subject: [PATCH 47/70] chore: drop python3.8 (#4) * chore: drop python3.8 * chore: compile C files for source control * Update setup.py --------- Co-authored-by: github-actions[bot] --- build/ops.txt | 2458 ++++++++++++++++++++++++------------------------- setup.py | 2 +- tox.ini | 12 +- 3 files changed, 1236 insertions(+), 1236 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 936de4d..d40a5c1 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,323 +1,641 @@ -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__:49) 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__:50) 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) 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 +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 :: 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] + 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 = 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__:63) else goto L1 + r0 = PyBytes_Check(val) + if r0 goto L1 else goto L3 :: bool L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 + inc_ref val + r1 = cast(bytes, val) + if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 L2: - r6 = PyLong_Check(r5) - if r6 goto L3 else goto L5 :: bool + return r1 L3: - r7 = unbox(int, r5) - dec_ref r5 - if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 + r2 = PyUnicode_Check(val) + if r2 goto L4 else goto L7 :: bool L4: - r8 = box(int, r7) - return r8 + inc_ref val + r3 = cast(str, val) + if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 L5: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + r4 = hexstr_to_bytes(r3) + dec_ref r3 + if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 L6: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + return r4 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__:69) else goto L8 + r5 = PyByteArray_Check(val) + if r5 goto L8 else goto L11 :: bool L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 + 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: - return r17 + r10 = cast(bytes, r9) + if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 + return r10 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__:70) else goto L12 + r11 = PyBool_Check(val) + if r11 goto L12 else goto L17 :: bool L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 + r12 = unbox(bool, val) + if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 L13: - return r22 + if r12 goto L14 else goto L15 :: bool L14: - r23 = :: union[int, faster_hexbytes.main.HexBytes] - return r23 -L15: - dec_ref r9 - goto L6 + r13 = b'\x01' + inc_ref r13 + r14 = r13 + goto L16 +L15: + r15 = b'\x00' + inc_ref r15 + r14 = r15 L16: - dec_ref r12 - goto L14 + return r14 L17: - dec_ref r9 - goto L14 + r16 = PyLong_Check(val) + if r16 goto L18 else goto L37 :: bool L18: - dec_ref r18 - goto L14 + 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 __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + 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: - inc_ref __mypyc_self__ - return __mypyc_self__ + if r4 goto L2 else goto L5 :: bool 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, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str -L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:73) else goto L1 -L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:73) else goto L2 -L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:73) else goto L3 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:73) else goto L4 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:73) else goto L5 + non_prefixed_hex = r6 + goto L6 L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:73) else goto L6 + inc_ref hexstr + non_prefixed_hex = hexstr L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:73) else goto L7 + 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: - return r22 + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 L8: - r23 = :: str - return r23 + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool L9: - dec_ref r9 - goto L8 + 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 - goto L8 + 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 to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - inc_ref __mypyc_self__ - return __mypyc_self__ + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L8 (error at :-1) else goto L2 L2: - r2 = PyMethod_New(__mypyc_self__, instance) - if is_error(r2) goto L4 else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - return r2 + 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: - 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 + 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 + +def __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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:79) else goto L1 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) else goto L3 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 L3: - return r6 + return r2 L4: - r7 = :: str + 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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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 __reduce___HexBytes_obj.__get__(__mypyc_self__, instance, owner): +def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit r2, r3 :: object @@ -337,1030 +655,712 @@ L4: r3 = :: object return r3 -def __reduce___HexBytes_obj.__call__(__mypyc_self__, self): - __mypyc_self__ :: faster_hexbytes.main.__reduce___HexBytes_obj +def __getitem___HexBytes_obj.__call__(__mypyc_self__, self, key): + __mypyc_self__ :: faster_hexbytes.main.__getitem___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]] + 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 = faster_hexbytes.main._bytes_new :: static - if is_error(r0) goto L1 else goto L3 + 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__:63) else goto L1 L1: - r1 = raise NameError('value for final name "_bytes_new" was not set') - if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 L2: - unreachable + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool 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__:89) else goto L4 + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 + r8 = box(int, r7) + return r8 L5: - r8 = (r2, r7) - inc_ref r0 - r9 = (r0, r8) - return r9 + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool L6: - r10 = :: tuple[object, tuple[object, bytes]] - return r10 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - dec_ref r2 + 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__:69) else goto L8 +L8: + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 +L9: + return r17 +L10: + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 +L12: + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) 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 __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 :: object - r121 :: object[1] - r122 :: object_ptr - r123, r124 :: object - r125 :: object[1] - r126 :: object_ptr - r127 :: object - r128 :: dict - r129 :: str - r130 :: i32 - r131 :: bit - r132 :: object - r133 :: None +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L48 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 L48 (error at :1) else goto L4 + return r2 L4: - typing = r8 :: module + 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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:73) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:73) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) dec_ref r8 - r9 = load_address hexbytes.main :: module - r10 = [r9] - r11 = load_address r10 - r12 = [14] + if is_error(r9) goto L8 (error at __repr__:73) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] 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 L48 else goto L5 :: bool + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:73) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:73) else goto L5 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 L48 (error at :15) else goto L6 + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:73) 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 L48 (error at :18) else goto L7 + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:73) 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 L48 (error at :22) else goto L8 + return r22 L8: - faster_hexbytes._utils = r30 :: module - dec_ref r30 - if 0 goto L9 else goto L9 :: bool + r23 = :: str + return r23 L9: - r31 = faster_hexbytes.main.globals :: static - r32 = 'Union' - r33 = CPyDict_GetItem(r31, r32) - if is_error(r33) goto L48 (error at :31) else goto L10 + dec_ref r9 + goto L8 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 L49 (error at :31) else goto L11 -L11: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) 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 L48 (error at :31) 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 L48 (error at :31) else goto L14 :: bool -L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) 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 L48 (error at :33) else goto L16 :: bool -L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 -L17: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 -L18: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 -L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 -L23: - r73 = r72 - goto L26 -L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 -L25: - r73 = r74 -L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 -L27: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 -L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool -L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 -L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool -L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 -L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool -L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool -L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 -L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type - return 1 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 - -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: + dec_ref r15 + goto L8 + +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:79) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 +L2: + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) 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__:89) else goto L2 :: bool +L2: 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 +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__:89) else goto L4 +L4: + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) 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 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 +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 :: object - r26 :: object[1] - r27 :: object_ptr - r28 :: object - r29 :: bit + r25 :: dict + r26, r27 :: object + r28 :: str + r29 :: dict r30 :: object - r31 :: bool - r32 :: object[1] - r33 :: object_ptr - r34 :: object - r35, r36 :: bytes + 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 :: object + r121 :: object[1] + r122 :: object_ptr + r123, r124 :: object + r125 :: object[1] + r126 :: object_ptr + r127 :: object + r128 :: dict + r129 :: str + r130 :: i32 + r131 :: bit + r132 :: object + r133 :: None 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 + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - if r4 goto L2 else goto L5 :: bool + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L48 (error at :-1) else goto L2 L2: - r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) - if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - r6 = cast(str, r5) - if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 + 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 L48 (error at :1) else goto L4 L4: - non_prefixed_hex = r6 - goto L6 + 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 L48 else goto L5 :: bool L5: - inc_ref hexstr - non_prefixed_hex = hexstr + r19 = ('mypyc_attr',) + r20 = 'mypy_extensions' + r21 = faster_hexbytes.main.globals :: static + r22 = CPyImport_ImportFromMany(r20, r19, r19, r21) + if is_error(r22) goto L48 (error at :15) else goto L6 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 + 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 L48 (error at :18) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + 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 L48 (error at :22) else goto L8 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + faster_hexbytes._utils = r30 :: module + dec_ref r30 + if 0 goto L9 else goto L9 :: 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 + r31 = faster_hexbytes.main.globals :: static + r32 = 'Union' + r33 = CPyDict_GetItem(r31, r32) + if is_error(r33) goto L48 (error at :31) else goto L10 L10: - padded_hex = r13 - goto L12 + 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 L49 (error at :31) else goto L11 L11: - padded_hex = non_prefixed_hex + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) else goto L12 L12: - r14 = PyUnicode_AsASCIIString(padded_hex) - if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 + 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 L48 (error at :31) else goto L13 L13: - goto L25 + 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 L48 (error at :31) else goto L14 :: bool 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 + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) else goto L15 L15: - r19 = CPy_ExceptionMatches(r18) - dec_ref r18 - if r19 goto L16 else goto L35 :: bool + 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 L48 (error at :33) else goto L16 :: 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 + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) 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 + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) 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 + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 + r64 = '__prepare__' + r65 = PyObject_HasAttr(r63, r64) + if r65 goto L20 else goto L24 :: bool L20: - unreachable + r66 = 'HexBytes' + r67 = '__prepare__' + r68 = CPyObject_GetAttr(r63, r67) + if is_error(r68) goto L51 (error at :37) else goto L21 L21: - CPy_Reraise() - if not 0 goto L23 else goto L38 :: bool + r69 = [r66, r61] + r70 = load_address r69 + r71 = PyObject_Vectorcall(r68, r70, 2, 0) + dec_ref r68 + if is_error(r71) goto L51 (error at :37) else goto L22 L22: - unreachable + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 L23: - CPy_RestoreExcInfo(r15) - dec_ref r15 - r29 = CPy_KeepPropagating() - if not r29 goto L31 else goto L24 :: bool + r73 = r72 + goto L26 L24: - unreachable + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 L25: - r30 = faster_hexbytes._utils.unhexlify :: static - if is_error(r30) goto L39 else goto L28 + r73 = r74 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 + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 L27: - unreachable + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 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 + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 + r80 = [r76] + r81 = load_address r80 + r82 = PyObject_Vectorcall(r79, r81, 1, 0) + dec_ref r79 + if is_error(r82) goto L54 (error at :48) else goto L30 L30: - return r35 + dec_ref r76 + r83 = '__new__' + r84 = CPyDict_SetItem(r73, r83, r82) + dec_ref r82 + r85 = r84 >= 0 :: signed + if not r85 goto L53 (error at :48) else goto L31 :: bool L31: - r36 = :: bytes - return r36 + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 L32: - dec_ref non_prefixed_hex - goto L31 + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool L33: - dec_ref padded_hex - goto L13 + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 L34: - dec_ref padded_hex - goto L23 + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool L35: - dec_ref padded_hex - goto L21 + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) else goto L36 L36: - dec_ref r22 - goto L23 + r95 = 'to_0x_hex' + r96 = CPyDict_SetItem(r73, r95, r94) + dec_ref r94 + r97 = r96 >= 0 :: signed + if not r97 goto L53 (error at :75) else goto L37 :: bool L37: - dec_ref r15 - goto L20 + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 L38: - dec_ref r15 - goto L22 + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) else goto L39 :: bool L39: - dec_ref r14 - goto L26 + r102 = 'HexBytes' + r103 = '__annotations__' + r104 = CPyDict_SetItem(r73, r103, r75) + dec_ref r75 + r105 = r104 >= 0 :: signed + if not r105 goto L52 (error at :37) else goto L40 :: bool 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: + r106 = 'mypyc filler docstring' + r107 = '__doc__' + r108 = CPyDict_SetItem(r73, r107, r106) + r109 = r108 >= 0 :: signed + if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type return 1 -L8: - r26 = :: None - return r26 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 def __top_level__(): r0, r1 :: object diff --git a/setup.py b/setup.py index 4df8ebe..a9fa6f0 100644 --- a/setup.py +++ b/setup.py @@ -62,7 +62,7 @@ url="https://github.com/ethereum/hexbytes", include_package_data=True, install_requires=[f"hexbytes=={version}"], - python_requires=">=3.8, <4", + python_requires=">=3.9, <4", extras_require=extras_require, py_modules=["faster_hexbytes"], license="MIT", 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] From cc1314f9414dc824a68ce9faeec1972b8c57a283 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 09:25:40 +0000 Subject: [PATCH 48/70] chore: compile C files for source control --- build/ops.txt | 2290 ++++++++++++++++++++++++------------------------- 1 file changed, 1145 insertions(+), 1145 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index d40a5c1..936de4d 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,641 +1,323 @@ -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 +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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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 :: 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 + 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 = PyBytes_Check(val) - if r0 goto L1 else goto L3 :: bool + 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__:63) else goto L1 L1: - inc_ref val - r1 = cast(bytes, val) - if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 L2: - return r1 + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool L3: - r2 = PyUnicode_Check(val) - if r2 goto L4 else goto L7 :: bool + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 L4: - inc_ref val - r3 = cast(str, val) - if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 + r8 = box(int, r7) + return r8 L5: - r4 = hexstr_to_bytes(r3) - dec_ref r3 - if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool L6: - return r4 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 L7: - r5 = PyByteArray_Check(val) - if r5 goto L8 else goto L11 :: bool + 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__:69) else goto L8 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 + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 L9: - r10 = cast(bytes, r9) - if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 + return r17 L10: - return r10 + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 L11: - r11 = PyBool_Check(val) - if r11 goto L12 else goto L17 :: bool + 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__:70) else goto L12 L12: - r12 = unbox(bool, val) - if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 L13: - if r12 goto L14 else goto L15 :: bool + return r22 L14: - r13 = b'\x01' - inc_ref r13 - r14 = r13 - goto L16 -L15: - r15 = b'\x00' - inc_ref r15 - r14 = r15 + r23 = :: union[int, faster_hexbytes.main.HexBytes] + return r23 +L15: + dec_ref r9 + goto L6 L16: - return r14 + dec_ref r12 + goto L14 L17: - r16 = PyLong_Check(val) - if r16 goto L18 else goto L37 :: bool + dec_ref r9 + goto L14 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 + dec_ref r18 + goto L14 -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 +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object 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 + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - if r4 goto L2 else goto L5 :: bool + inc_ref __mypyc_self__ + return __mypyc_self__ 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 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 +L3: + return r2 L4: - non_prefixed_hex = r6 - goto L6 + 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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:73) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:73) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) + dec_ref r8 + if is_error(r9) goto L8 (error at __repr__:73) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] + r13 = load_address r12 + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:73) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:73) else goto L5 L5: - inc_ref hexstr - non_prefixed_hex = hexstr + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:73) else goto L6 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 + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:73) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + return r22 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + r23 = :: str + return r23 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 + dec_ref r9 + goto L8 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 + goto L8 -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 +def to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L8 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 - -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 + 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 +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 = to_bytes(val) - if is_error(r0) goto L7 (error at __new__:49) else goto L1 + 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:79) else goto L1 L1: - r1 = faster_hexbytes.main._bytes_new :: static - if is_error(r1) goto L8 else goto L4 + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 L2: - r2 = raise NameError('value for final name "_bytes_new" was not set') - if not r2 goto L7 (error at __new__:50) else goto L3 :: bool + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) else goto L3 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) else goto L6 -L6: return r6 -L7: - r7 = :: faster_hexbytes.main.HexBytes +L4: + r7 = :: str return r7 -L8: - dec_ref r0 - goto L2 -L9: - dec_ref r0 - goto L7 -def __getitem___HexBytes_obj.__get__(__mypyc_self__, instance, owner): +def __reduce___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit r2, r3 :: object @@ -655,317 +337,61 @@ L4: r3 = :: object return r3 -def __getitem___HexBytes_obj.__call__(__mypyc_self__, self, key): - __mypyc_self__ :: faster_hexbytes.main.__getitem___HexBytes_obj +def __reduce___HexBytes_obj.__call__(__mypyc_self__, self): + __mypyc_self__ :: faster_hexbytes.main.__reduce___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] + 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 = 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__:63) else goto L1 + r0 = faster_hexbytes.main._bytes_new :: static + if is_error(r0) goto L1 else goto L3 L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 + r1 = raise NameError('value for final name "_bytes_new" was not set') + if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool L2: - r6 = PyLong_Check(r5) - if r6 goto L3 else goto L5 :: bool + unreachable L3: - r7 = unbox(int, r5) - dec_ref r5 - if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 + 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__:89) else goto L4 L4: - r8 = box(int, r7) - return r8 + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 L5: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + r8 = (r2, r7) + inc_ref r0 + r9 = (r0, r8) + return r9 L6: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + r10 = :: tuple[object, tuple[object, bytes]] + return r10 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__:69) else goto L8 -L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 -L9: - return r17 -L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 -L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 -L13: - return r22 -L14: - r23 = :: union[int, faster_hexbytes.main.HexBytes] - return r23 -L15: - dec_ref r9 + dec_ref r2 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, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str -L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:73) else goto L1 -L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:73) else goto L2 -L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:73) else goto L3 -L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:73) else goto L4 -L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:73) else goto L5 -L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:73) else goto L6 -L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:73) else goto L7 -L7: - return r22 -L8: - r23 = :: str - return r23 -L9: - dec_ref r9 - goto L8 -L10: - dec_ref r15 - goto L8 - -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:79) else goto L1 -L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 -L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) 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__:89) 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__:89) else goto L4 -L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) 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 +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 @@ -1067,300 +493,874 @@ def __top_level__(): r132 :: object r133 :: None L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + 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 L48 (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 L48 (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 L48 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 L48 (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 L48 (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 L48 (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 L48 (error at :31) 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 L49 (error at :31) else goto L11 +L11: + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) 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 L48 (error at :31) 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 L48 (error at :31) else goto L14 :: bool +L14: + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) 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 L48 (error at :33) else goto L16 :: bool +L16: + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) else goto L17 +L17: + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) else goto L18 +L18: + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 +L22: + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 +L23: + r73 = r72 + goto L26 +L24: + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 +L25: + r73 = r74 +L26: + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 +L27: + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 +L28: + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool +L31: + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 +L32: + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool +L33: + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 +L34: + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool +L35: + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool +L37: + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 +L38: + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type + return 1 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 + +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: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L48 (error at :-1) else goto L2 + if r4 goto L2 else goto L5 :: bool L2: - builtins = r4 :: module - dec_ref r4 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 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 L48 (error at :1) else goto L4 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) 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 L48 else goto L5 :: bool + non_prefixed_hex = r6 + goto L6 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 L48 (error at :15) else goto L6 + inc_ref hexstr + non_prefixed_hex = hexstr 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 L48 (error at :18) else goto L7 + 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: - 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 L48 (error at :22) else goto L8 + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 L8: - faster_hexbytes._utils = r30 :: module - dec_ref r30 - if 0 goto L9 else goto L9 :: bool + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool L9: - r31 = faster_hexbytes.main.globals :: static - r32 = 'Union' - r33 = CPyDict_GetItem(r31, r32) - if is_error(r33) goto L48 (error at :31) else goto L10 + 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: - 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 L49 (error at :31) else goto L11 + padded_hex = r13 + goto L12 L11: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) else goto L12 + padded_hex = non_prefixed_hex 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 L48 (error at :31) else goto L13 + r14 = PyUnicode_AsASCIIString(padded_hex) + if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 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 L48 (error at :31) else goto L14 :: bool + goto L25 L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) else goto L15 + 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: - 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 L48 (error at :33) else goto L16 :: bool + r19 = CPy_ExceptionMatches(r18) + dec_ref r18 + if r19 goto L16 else goto L35 :: bool L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 + 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: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 + 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: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) else goto L19 + 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: - r64 = '__prepare__' - r65 = PyObject_HasAttr(r63, r64) - if r65 goto L20 else goto L24 :: bool + 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: - r66 = 'HexBytes' - r67 = '__prepare__' - r68 = CPyObject_GetAttr(r63, r67) - if is_error(r68) goto L51 (error at :37) 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 L51 (error at :37) else goto L22 + unreachable +L21: + CPy_Reraise() + if not 0 goto L23 else goto L38 :: bool L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 + unreachable L23: - r73 = r72 - goto L26 + CPy_RestoreExcInfo(r15) + dec_ref r15 + r29 = CPy_KeepPropagating() + if not r29 goto L31 else goto L24 :: bool L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 + unreachable L25: - r73 = r74 + r30 = faster_hexbytes._utils.unhexlify :: static + if is_error(r30) goto L39 else goto L28 L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 + 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: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 + unreachable L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) else goto L29 + 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: - r80 = [r76] - r81 = load_address r80 - r82 = PyObject_Vectorcall(r79, r81, 1, 0) - dec_ref r79 - if is_error(r82) goto L54 (error at :48) else goto L30 + dec_ref r14 + r35 = cast(bytes, r34) + if is_error(r35) goto L31 (error at hexstr_to_bytes:58) 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 L53 (error at :48) else goto L31 :: bool + return r35 L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 + r36 = :: bytes + return r36 L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool + dec_ref non_prefixed_hex + goto L31 L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 + dec_ref padded_hex + goto L13 L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool + dec_ref padded_hex + goto L23 L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) else goto L36 + dec_ref padded_hex + goto L21 L36: - r95 = 'to_0x_hex' - r96 = CPyDict_SetItem(r73, r95, r94) - dec_ref r94 - r97 = r96 >= 0 :: signed - if not r97 goto L53 (error at :75) else goto L37 :: bool + dec_ref r22 + goto L23 L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 + dec_ref r15 + goto L20 L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) else goto L39 :: bool + dec_ref r15 + goto L22 L39: - r102 = 'HexBytes' - r103 = '__annotations__' - r104 = CPyDict_SetItem(r73, r103, r75) - dec_ref r75 - r105 = r104 >= 0 :: signed - if not r105 goto L52 (error at :37) else goto L40 :: bool + dec_ref r14 + goto L26 L40: - r106 = 'mypyc filler docstring' - r107 = '__doc__' - r108 = CPyDict_SetItem(r73, r107, r106) - r109 = r108 >= 0 :: signed - if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type + 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 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 +L8: + r26 = :: None + return r26 def __top_level__(): r0, r1 :: object From 3c496dd48b819972c2848944edc7405101fe89dc Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 05:55:05 -0400 Subject: [PATCH 49/70] feat(cicd): tox github action (#3) * feat(cicd): tox github action * chore: compile C files for source control * Update tox.yaml * chore: compile C files for source control * Update tox.yaml * chore: compile C files for source control * include mypy_extensions dep * chore: compile C files for source control * include all matrix combos * rename job * chore: compile C files for source control * fix matrix * chore: compile C files for source control --------- Co-authored-by: github-actions[bot] --- .github/workflows/tox.yaml | 47 +++++++++ build/ops.txt | 206 ++++++++++++++++++------------------- setup.py | 2 +- 3 files changed, 151 insertions(+), 104 deletions(-) create mode 100644 .github/workflows/tox.yaml diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml new file mode 100644 index 0000000..36b0e10 --- /dev/null +++ b/.github/workflows/tox.yaml @@ -0,0 +1,47 @@ +name: Tox + +on: + push: + branches: [main, master] + pull_request: + branches: [main, master] + schedule: + - cron: '0 12 * * 1-5' # Weekdays 12:00 UTC + +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/build/ops.txt b/build/ops.txt index 936de4d..5ed80ec 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -788,6 +788,109 @@ L55: dec_ref r116 goto L48 +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 @@ -1361,106 +1464,3 @@ L7: L8: r26 = :: None return r26 - -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 diff --git a/setup.py b/setup.py index a9fa6f0..9df5152 100644 --- a/setup.py +++ b/setup.py @@ -61,7 +61,7 @@ author_email="snakecharmers@ethereum.org", url="https://github.com/ethereum/hexbytes", include_package_data=True, - install_requires=[f"hexbytes=={version}"], + install_requires=[f"hexbytes=={version}", "mypy_extensions"], python_requires=">=3.9, <4", extras_require=extras_require, py_modules=["faster_hexbytes"], From ba5b861aa66f63ffa62c51668108c7a5c627ebc1 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 06:01:15 -0400 Subject: [PATCH 50/70] Create release.yaml --- .github/workflows/release.yaml | 199 +++++++++++++++++++++++++++++++++ 1 file changed, 199 insertions(+) create mode 100644 .github/workflows/release.yaml diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml new file mode 100644 index 0000000..3608a5b --- /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 + + - 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 From ba17d876a01ee04830d2cc7bf79efd6312b601da Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 10:01:38 +0000 Subject: [PATCH 51/70] chore: compile C files for source control --- build/ops.txt | 206 +++++++++++++++++++++++++------------------------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 5ed80ec..a8ead04 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,3 +1,106 @@ +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 __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit @@ -788,109 +891,6 @@ L55: dec_ref r116 goto L48 -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 From a5cee88b28664bb7d68ce6df9f6773a776a26767 Mon Sep 17 00:00:00 2001 From: BobTheBuidler Date: Tue, 30 Sep 2025 10:05:45 +0000 Subject: [PATCH 52/70] fix comment --- faster_hexbytes/_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faster_hexbytes/_utils.py b/faster_hexbytes/_utils.py index 991307f..baa1f95 100644 --- a/faster_hexbytes/_utils.py +++ b/faster_hexbytes/_utils.py @@ -10,7 +10,7 @@ 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. From c7c2ec9239a904cad8b9dac642873cfc7be77eaa Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 10:07:00 +0000 Subject: [PATCH 53/70] chore: compile C files for source control --- build/ops.txt | 206 +++++++++++++++++++++++++------------------------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index a8ead04..936de4d 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,106 +1,3 @@ -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 __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit @@ -1464,3 +1361,106 @@ L7: L8: r26 = :: None return r26 + +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 From 76b6c74f032ab1906306a8417f03e809911c357a Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 15:17:54 -0400 Subject: [PATCH 54/70] feat: microoptimize `__repr__` (#11) * feat: microoptimize `__repr__` * chore: compile C files for source control --------- Co-authored-by: github-actions[bot] --- build/__native_6a32f4913d613d6a7ddf.c | 116 +++-------- build/ops.txt | 289 +++++++++++--------------- faster_hexbytes/main.py | 2 +- 3 files changed, 153 insertions(+), 254 deletions(-) diff --git a/build/__native_6a32f4913d613d6a7ddf.c b/build/__native_6a32f4913d613d6a7ddf.c index 7e84d32..2715d45 100644 --- a/build/__native_6a32f4913d613d6a7ddf.c +++ b/build/__native_6a32f4913d613d6a7ddf.c @@ -2045,97 +2045,38 @@ fail: ; 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_r2; - PyObject *cpy_r_r3; + PyObject **cpy_r_r3; PyObject *cpy_r_r4; - PyObject **cpy_r_r6; + 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_r13; - PyObject *cpy_r_r14; - PyObject *cpy_r_r15; - PyObject *cpy_r_r16; - PyObject *cpy_r_r17; - CPyPtr cpy_r_r18; - CPyPtr cpy_r_r19; - CPyPtr cpy_r_r20; - CPyPtr cpy_r_r21; - PyObject *cpy_r_r22; - PyObject *cpy_r_r23; - cpy_r_r0 = CPyStatics[17]; /* '' */ - cpy_r_r1 = CPyStatics[38]; /* 'HexBytes(' */ - cpy_r_r2 = CPyStatics[19]; /* '{!r:{}}' */ - cpy_r_r3 = CPyStatics[24]; /* '0x' */ - cpy_r_r4 = CPyStatics[15]; /* 'hex' */ - PyObject *cpy_r_r5[1] = {cpy_r_self}; - cpy_r_r6 = (PyObject **)&cpy_r_r5; - cpy_r_r7 = PyObject_VectorcallMethod(cpy_r_r4, cpy_r_r6, 9223372036854775809ULL, 0); - if (unlikely(cpy_r_r7 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); - goto CPyL8; - } - if (likely(PyUnicode_Check(cpy_r_r7))) - cpy_r_r8 = cpy_r_r7; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals, "str", cpy_r_r7); - goto CPyL8; - } - cpy_r_r9 = PyUnicode_Concat(cpy_r_r3, cpy_r_r8); - CPy_DECREF(cpy_r_r8); - if (unlikely(cpy_r_r9 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); - goto CPyL8; - } - cpy_r_r10 = CPyStatics[17]; /* '' */ - cpy_r_r11 = CPyStatics[20]; /* 'format' */ - PyObject *cpy_r_r12[3] = {cpy_r_r2, cpy_r_r9, cpy_r_r10}; - cpy_r_r13 = (PyObject **)&cpy_r_r12; - cpy_r_r14 = PyObject_VectorcallMethod(cpy_r_r11, cpy_r_r13, 9223372036854775811ULL, 0); - if (unlikely(cpy_r_r14 == NULL)) { + cpy_r_r0 = CPyStatics[38]; /* "HexBytes('0x" */ + cpy_r_r1 = CPyStatics[15]; /* '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__", 73, CPyStatic_main___globals); - goto CPyL9; + goto CPyL4; } - CPy_DECREF(cpy_r_r9); - if (likely(PyUnicode_Check(cpy_r_r14))) - cpy_r_r15 = cpy_r_r14; + if (likely(PyUnicode_Check(cpy_r_r4))) + cpy_r_r5 = cpy_r_r4; else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals, "str", cpy_r_r14); - goto CPyL8; - } - cpy_r_r16 = CPyStatics[39]; /* ')' */ - cpy_r_r17 = PyList_New(3); - if (unlikely(cpy_r_r17 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); - goto CPyL10; + CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals, "str", cpy_r_r4); + goto CPyL4; } - cpy_r_r18 = (CPyPtr)&((PyListObject *)cpy_r_r17)->ob_item; - cpy_r_r19 = *(CPyPtr *)cpy_r_r18; - CPy_INCREF(cpy_r_r1); - *(PyObject * *)cpy_r_r19 = cpy_r_r1; - cpy_r_r20 = cpy_r_r19 + 8; - *(PyObject * *)cpy_r_r20 = cpy_r_r15; - CPy_INCREF(cpy_r_r16); - cpy_r_r21 = cpy_r_r19 + 16; - *(PyObject * *)cpy_r_r21 = cpy_r_r16; - cpy_r_r22 = PyUnicode_Join(cpy_r_r0, cpy_r_r17); - CPy_DECREF_NO_IMM(cpy_r_r17); - if (unlikely(cpy_r_r22 == NULL)) { + cpy_r_r6 = CPyStatics[39]; /* "')" */ + 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__", 73, CPyStatic_main___globals); - goto CPyL8; + goto CPyL4; } - return cpy_r_r22; -CPyL8: ; - cpy_r_r23 = NULL; - return cpy_r_r23; -CPyL9: ; - CPy_DecRef(cpy_r_r9); - goto CPyL8; -CPyL10: ; - CPy_DecRef(cpy_r_r15); - goto CPyL8; + 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) { @@ -2949,11 +2890,12 @@ const char * const CPyLit_Str[] = { "\002\022UnicodeDecodeError\vhex string ", "\002( may only contain [0-9a-fA-F] characters\bbinascii", "\006\031faster_hexbytes/_utils.py\b\005Final\005Union\006typing\tunhexlify", - "\b\v__getitem__\tHexBytes(\001)\rTYPE_CHECKING\bCallable\005Tuple\004Type\boverload", - "\005\rhexbytes.main\027faster_hexbytes/main.py\nmypyc_attr\017mypy_extensions\004Self", - "\005\021typing_extensions\bto_bytes\026faster_hexbytes._utils\tbytearray\tBytesLike", - "\006\a__new__\n_bytes_new\v__prepare__\fstaticmethod\b__repr__\tto_0x_hex", - "\005\n__reduce__\017__annotations__\026mypyc filler docstring\a__doc__\n__module__", + "\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__", "\001\fnative_class", "", }; diff --git a/build/ops.txt b/build/ops.txt index 936de4d..0fa83b5 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -200,74 +200,31 @@ L4: def __repr___HexBytes_obj.__call__(__mypyc_self__, self): __mypyc_self__ :: faster_hexbytes.main.__repr___HexBytes_obj self :: faster_hexbytes.main.HexBytes - r0, r1, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str + r0, r1 :: str + r2 :: object[1] + r3 :: object_ptr + r4 :: object + r5, r6, r7, r8 :: str L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:73) else goto L1 + 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__:73) else goto L1 L1: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:73) else goto L2 + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at __repr__:73) else goto L2 L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:73) else goto L3 + r6 = "')" + r7 = CPyStr_Build(3, r0, r5, r6) + dec_ref r5 + if is_error(r7) goto L4 (error at __repr__:73) else goto L3 L3: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:73) else goto L4 + return r7 L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:73) else goto L5 -L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:73) else goto L6 -L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:73) else goto L7 -L7: - return r22 -L8: - r23 = :: str - return r23 -L9: - dec_ref r9 - goto L8 -L10: - dec_ref r15 - goto L8 + r8 = :: str + return r8 def to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object @@ -788,6 +745,109 @@ L55: dec_ref r116 goto L48 +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 @@ -1361,106 +1421,3 @@ L7: L8: r26 = :: None return r26 - -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 diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index ae9958a..8cbc5c2 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -70,7 +70,7 @@ def __getitem__( # noqa: F811 return cls(result) def __repr__(self) -> str: - return f"HexBytes({'0x' + self.hex()!r})" + return f"HexBytes('0x{self.hex()}')" def to_0x_hex(self) -> str: """ From 5ef715f86374f61bfdf52e2885f4ac9cd7b24a31 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 19:18:37 +0000 Subject: [PATCH 55/70] chore: compile C files for source control --- build/ops.txt | 2590 ++++++++++++++++++++++++------------------------- 1 file changed, 1295 insertions(+), 1295 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 0fa83b5..390263a 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,454 +1,608 @@ -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__:49) 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__:50) 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) 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 +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 :: 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] + 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 = 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__:63) else goto L1 + r0 = PyBytes_Check(val) + if r0 goto L1 else goto L3 :: bool L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) else goto L2 + inc_ref val + r1 = cast(bytes, val) + if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 L2: - r6 = PyLong_Check(r5) - if r6 goto L3 else goto L5 :: bool + return r1 L3: - r7 = unbox(int, r5) - dec_ref r5 - if is_error(r7) goto L14 (error at __getitem__:65) else goto L4 + r2 = PyUnicode_Check(val) + if r2 goto L4 else goto L7 :: bool L4: - r8 = box(int, r7) - return r8 + inc_ref val + r3 = cast(str, val) + if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 L5: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + r4 = hexstr_to_bytes(r3) + dec_ref r3 + if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 L6: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + return r4 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__:69) else goto L8 + r5 = PyByteArray_Check(val) + if r5 goto L8 else goto L11 :: bool L8: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 + 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: - return r17 + r10 = cast(bytes, r9) + if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 + return r10 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__:70) else goto L12 + r11 = PyBool_Check(val) + if r11 goto L12 else goto L17 :: bool L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) else goto L13 + r12 = unbox(bool, val) + if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 L13: - return r22 + if r12 goto L14 else goto L15 :: bool L14: - r23 = :: union[int, faster_hexbytes.main.HexBytes] - return r23 -L15: - dec_ref r9 - goto L6 + r13 = b'\x01' + inc_ref r13 + r14 = r13 + goto L16 +L15: + r15 = b'\x00' + inc_ref r15 + r14 = r15 L16: - dec_ref r12 - goto L14 + return r14 L17: - dec_ref r9 - goto L14 + r16 = PyLong_Check(val) + if r16 goto L18 else goto L37 :: bool L18: - dec_ref r18 - goto L14 + 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 __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): - __mypyc_self__, instance, owner, r0 :: object - r1 :: bit - r2, r3 :: object +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 = load_address _Py_NoneStruct - r1 = instance == r0 - if r1 goto L1 else goto L2 :: bool + 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: - inc_ref __mypyc_self__ - return __mypyc_self__ + if r4 goto L2 else goto L5 :: bool 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__:73) else goto L1 -L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at __repr__:73) else goto L2 -L2: - r6 = "')" - r7 = CPyStr_Build(3, r0, r5, r6) - dec_ref r5 - if is_error(r7) goto L4 (error at __repr__:73) 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 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 L3: - return r2 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 L4: - r3 = :: object - return r3 + 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 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 +def __top_level__(): + r0, r1 :: object + r2 :: bit + r3 :: str r4 :: object - r5, r6, r7 :: str + 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 = '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:79) else goto L1 + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L8 (error at :-1) else goto L2 L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - return r6 + 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: - 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__:89) 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__:89) else goto L4 -L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 + 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: - r8 = (r2, r7) - inc_ref r0 - r9 = (r0, r8) - return r9 + 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: - r10 = :: tuple[object, tuple[object, bytes]] - return r10 + 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: - dec_ref r2 - goto L6 + return 1 +L8: + r26 = :: None + return r26 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 + 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 :: 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 :: object - r121 :: object[1] - r122 :: object_ptr - r123, r124 :: object - r125 :: object[1] - r126 :: object_ptr - r127 :: object - r128 :: dict - r129 :: str - r130 :: i32 - r131 :: bit - r132 :: object - r133 :: None + 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 @@ -457,967 +611,813 @@ L0: L1: r3 = 'builtins' r4 = PyImport_Import(r3) - if is_error(r4) goto L48 (error at :-1) else goto L2 + if is_error(r4) goto L12 (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 L48 (error at :1) else goto L4 + 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: - 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 L48 else goto L5 :: bool + 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: - r19 = ('mypyc_attr',) - r20 = 'mypy_extensions' - r21 = faster_hexbytes.main.globals :: static - r22 = CPyImport_ImportFromMany(r20, r19, r19, r21) - if is_error(r22) goto L48 (error at :15) else goto L6 + 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: - 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 L48 (error at :18) else goto L7 + 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: - 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 L48 (error at :22) else goto L8 + 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: - faster_hexbytes._utils = r30 :: module - dec_ref r30 - if 0 goto L9 else goto L9 :: bool + 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: - r31 = faster_hexbytes.main.globals :: static - r32 = 'Union' - r33 = CPyDict_GetItem(r31, r32) - if is_error(r33) goto L48 (error at :31) else goto L10 + r29 = cast(str, r28) + if is_error(r29) goto L12 (error at :11) 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 L49 (error at :31) else goto L11 + 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: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) else goto L12 + return 1 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 L48 (error at :31) else goto L13 + r34 = :: None + return r34 + +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__:49) 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__:50) 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__:50) else goto L5 +L5: + dec_ref r0 + r6 = cast(faster_hexbytes.main.HexBytes, r5) + if is_error(r6) goto L7 (error at __new__:50) 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__:63) else goto L1 +L1: + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:63) 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__:65) 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__:69) 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__:69) else goto L8 +L8: + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 +L9: + return r17 +L10: + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:70) 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__:70) else goto L12 +L12: + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:70) 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 L48 (error at :31) else goto L14 :: bool + return r22 L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) else goto L15 + r23 = :: union[int, faster_hexbytes.main.HexBytes] + return r23 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 L48 (error at :33) else goto L16 :: bool + dec_ref r9 + goto L6 L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 -L17: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 + dec_ref r12 + goto L14 +L17: + dec_ref r9 + goto L14 L18: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) 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 L51 (error at :37) 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 L51 (error at :37) else goto L22 -L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 -L23: - r73 = r72 - goto L26 -L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 -L25: - r73 = r74 -L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 -L27: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 -L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) 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 L54 (error at :48) 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 L53 (error at :48) else goto L31 :: bool -L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 -L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool -L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 -L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool -L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) 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 L53 (error at :75) else goto L37 :: bool -L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 -L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type - return 1 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 + dec_ref r18 + goto L14 -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 +def __repr___HexBytes_obj.__get__(__mypyc_self__, instance, owner): + __mypyc_self__, instance, owner, r0 :: object + r1 :: bit + r2, r3 :: object L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + r0 = load_address _Py_NoneStruct + r1 = instance == r0 + if r1 goto L1 else goto L2 :: bool L1: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L12 (error at :-1) else goto L2 + inc_ref __mypyc_self__ + return __mypyc_self__ L2: - builtins = r4 :: module - dec_ref r4 + r2 = PyMethod_New(__mypyc_self__, instance) + if is_error(r2) goto L4 else goto L3 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 + return r2 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 + r3 = :: object + return r3 -def to_bytes(val): - val :: union[bytes, str, object, bool, int] - r0 :: bit - r1 :: bytes - r2 :: bit - r3 :: str - r4 :: bytes - r5 :: bit +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__:73) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at __repr__:73) else goto L2 +L2: + r6 = "')" + r7 = CPyStr_Build(3, r0, r5, r6) + dec_ref r5 + if is_error(r7) goto L4 (error at __repr__:73) 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:79) else goto L1 +L1: + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 +L2: + r6 = CPyStr_Build(2, r0, r5) + dec_ref r5 + if is_error(r6) goto L4 (error at to_0x_hex:79) 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 :: 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 + r7 :: bytes + r8 :: tuple[object, bytes] + r9, r10 :: tuple[object, tuple[object, bytes]] L0: - r0 = PyBytes_Check(val) - if r0 goto L1 else goto L3 :: bool + r0 = faster_hexbytes.main._bytes_new :: static + if is_error(r0) goto L1 else goto L3 L1: - inc_ref val - r1 = cast(bytes, val) - if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 + r1 = raise NameError('value for final name "_bytes_new" was not set') + if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool L2: - return r1 + unreachable L3: - r2 = PyUnicode_Check(val) - if r2 goto L4 else goto L7 :: bool + 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__:89) else goto L4 L4: - inc_ref val - r3 = cast(str, val) - if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 + r7 = cast(bytes, r6) + if is_error(r7) goto L7 (error at __reduce__:89) 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 + r8 = (r2, r7) + inc_ref r0 + r9 = (r0, r8) + return r9 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: + r10 = :: tuple[object, tuple[object, bytes]] 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 +L7: + dec_ref r2 + goto L6 -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 +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 :: object - r26 :: object[1] - r27 :: object_ptr - r28 :: object - r29 :: bit + r25 :: dict + r26, r27 :: object + r28 :: str + r29 :: dict r30 :: object - r31 :: bool - r32 :: object[1] - r33 :: object_ptr - r34 :: object - r35, r36 :: bytes + 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 :: object + r121 :: object[1] + r122 :: object_ptr + r123, r124 :: object + r125 :: object[1] + r126 :: object_ptr + r127 :: object + r128 :: dict + r129 :: str + r130 :: i32 + r131 :: bit + r132 :: object + r133 :: None 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 + r0 = builtins :: module + r1 = load_address _Py_NoneStruct + r2 = r0 != r1 + if r2 goto L3 else goto L1 :: bool L1: - if r4 goto L2 else goto L5 :: bool + r3 = 'builtins' + r4 = PyImport_Import(r3) + if is_error(r4) goto L48 (error at :-1) else goto L2 L2: - r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) - if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 + builtins = r4 :: module + dec_ref r4 L3: - r6 = cast(str, r5) - if is_error(r6) goto L31 (error at hexstr_to_bytes:41) else goto L4 + 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 L48 (error at :1) else goto L4 L4: - non_prefixed_hex = r6 - goto L6 + 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 L48 else goto L5 :: bool L5: - inc_ref hexstr - non_prefixed_hex = hexstr + r19 = ('mypyc_attr',) + r20 = 'mypy_extensions' + r21 = faster_hexbytes.main.globals :: static + r22 = CPyImport_ImportFromMany(r20, r19, r19, r21) + if is_error(r22) goto L48 (error at :15) else goto L6 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 + 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 L48 (error at :18) else goto L7 L7: - r9 = r7 << 1 - r10 = CPyTagged_Remainder(r9, 4) - if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 + 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 L48 (error at :22) else goto L8 L8: - r11 = r10 != 0 - dec_ref r10 :: int - if r11 goto L9 else goto L11 :: bool + faster_hexbytes._utils = r30 :: module + dec_ref r30 + if 0 goto L9 else goto L9 :: 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 + r31 = faster_hexbytes.main.globals :: static + r32 = 'Union' + r33 = CPyDict_GetItem(r31, r32) + if is_error(r33) goto L48 (error at :31) else goto L10 L10: - padded_hex = r13 - goto L12 + 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 L49 (error at :31) else goto L11 L11: - padded_hex = non_prefixed_hex + r40 = load_address PyLong_Type + r41 = builtins :: module + r42 = 'memoryview' + r43 = CPyObject_GetAttr(r41, r42) + if is_error(r43) goto L50 (error at :31) else goto L12 L12: - r14 = PyUnicode_AsASCIIString(padded_hex) - if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 + 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 L48 (error at :31) else goto L13 L13: - goto L25 + 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 L48 (error at :31) else goto L14 :: bool 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 + r51 = load_address PyBytes_Type + r52 = '__new__' + r53 = CPyObject_GetAttr(r51, r52) + if is_error(r53) goto L48 (error at :33) else goto L15 L15: - r19 = CPy_ExceptionMatches(r18) - dec_ref r18 - if r19 goto L16 else goto L35 :: bool + 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 L48 (error at :33) else goto L16 :: 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 + r58 = hexbytes.main :: module + r59 = 'HexBytes' + r60 = CPyObject_GetAttr(r58, r59) + if is_error(r60) goto L48 (error at :37) 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 + r61 = PyTuple_Pack(1, r60) + dec_ref r60 + if is_error(r61) goto L48 (error at :37) 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 + r62 = load_address PyType_Type + r63 = CPy_CalculateMetaclass(r62, r61) + if is_error(r63) goto L51 (error at :37) 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 + r64 = '__prepare__' + r65 = PyObject_HasAttr(r63, r64) + if r65 goto L20 else goto L24 :: bool L20: - unreachable + r66 = 'HexBytes' + r67 = '__prepare__' + r68 = CPyObject_GetAttr(r63, r67) + if is_error(r68) goto L51 (error at :37) else goto L21 L21: - CPy_Reraise() - if not 0 goto L23 else goto L38 :: bool + r69 = [r66, r61] + r70 = load_address r69 + r71 = PyObject_Vectorcall(r68, r70, 2, 0) + dec_ref r68 + if is_error(r71) goto L51 (error at :37) else goto L22 L22: - unreachable + r72 = cast(dict, r71) + if is_error(r72) goto L51 (error at :37) else goto L23 L23: - CPy_RestoreExcInfo(r15) - dec_ref r15 - r29 = CPy_KeepPropagating() - if not r29 goto L31 else goto L24 :: bool + r73 = r72 + goto L26 L24: - unreachable + r74 = PyDict_New() + if is_error(r74) goto L51 (error at :37) else goto L25 L25: - r30 = faster_hexbytes._utils.unhexlify :: static - if is_error(r30) goto L39 else goto L28 + r73 = r74 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 + r75 = PyDict_New() + if is_error(r75) goto L52 (error at :37) else goto L27 L27: - unreachable + r76 = __new___HexBytes_obj() + if is_error(r76) goto L53 (error at :48) else goto L28 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 + r77 = builtins :: module + r78 = 'staticmethod' + r79 = CPyObject_GetAttr(r77, r78) + if is_error(r79) goto L54 (error at :48) 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 + r80 = [r76] + r81 = load_address r80 + r82 = PyObject_Vectorcall(r79, r81, 1, 0) + dec_ref r79 + if is_error(r82) goto L54 (error at :48) else goto L30 L30: - return r35 + dec_ref r76 + r83 = '__new__' + r84 = CPyDict_SetItem(r73, r83, r82) + dec_ref r82 + r85 = r84 >= 0 :: signed + if not r85 goto L53 (error at :48) else goto L31 :: bool L31: - r36 = :: bytes - return r36 + r86 = __getitem___HexBytes_obj() + if is_error(r86) goto L53 (error at :60) else goto L32 L32: - dec_ref non_prefixed_hex - goto L31 + r87 = '__getitem__' + r88 = CPyDict_SetItem(r73, r87, r86) + dec_ref r86 + r89 = r88 >= 0 :: signed + if not r89 goto L53 (error at :60) else goto L33 :: bool L33: - dec_ref padded_hex - goto L13 + r90 = __repr___HexBytes_obj() + if is_error(r90) goto L53 (error at :72) else goto L34 L34: - dec_ref padded_hex - goto L23 + r91 = '__repr__' + r92 = CPyDict_SetItem(r73, r91, r90) + dec_ref r90 + r93 = r92 >= 0 :: signed + if not r93 goto L53 (error at :72) else goto L35 :: bool L35: - dec_ref padded_hex - goto L21 + r94 = to_0x_hex_HexBytes_obj() + if is_error(r94) goto L53 (error at :75) else goto L36 L36: - dec_ref r22 - goto L23 + r95 = 'to_0x_hex' + r96 = CPyDict_SetItem(r73, r95, r94) + dec_ref r94 + r97 = r96 >= 0 :: signed + if not r97 goto L53 (error at :75) else goto L37 :: bool L37: - dec_ref r15 - goto L20 + r98 = __reduce___HexBytes_obj() + if is_error(r98) goto L53 (error at :81) else goto L38 L38: - dec_ref r15 - goto L22 + r99 = '__reduce__' + r100 = CPyDict_SetItem(r73, r99, r98) + dec_ref r98 + r101 = r100 >= 0 :: signed + if not r101 goto L53 (error at :81) else goto L39 :: bool L39: - dec_ref r14 - goto L26 + r102 = 'HexBytes' + r103 = '__annotations__' + r104 = CPyDict_SetItem(r73, r103, r75) + dec_ref r75 + r105 = r104 >= 0 :: signed + if not r105 goto L52 (error at :37) else goto L40 :: bool 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: + r106 = 'mypyc filler docstring' + r107 = '__doc__' + r108 = CPyDict_SetItem(r73, r107, r106) + r109 = r108 >= 0 :: signed + if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 +L44: + r120 = box(bool, 0) + r121 = [r120] + r122 = load_address r121 + r123 = ('native_class',) + r124 = PyObject_Vectorcall(r119, r122, 0, r123) + dec_ref r119 + if is_error(r124) goto L55 (error at :36) else goto L45 +L45: + r125 = [r116] + r126 = load_address r125 + r127 = PyObject_Vectorcall(r124, r126, 1, 0) + dec_ref r124 + if is_error(r127) goto L55 (error at :37) else goto L46 +L46: + dec_ref r116 + faster_hexbytes.main.HexBytes = r127 :: type + r128 = faster_hexbytes.main.globals :: static + r129 = 'HexBytes' + r130 = PyDict_SetItem(r128, r129, r127) + dec_ref r127 + r131 = r130 >= 0 :: signed + if not r131 goto L48 (error at :37) else goto L47 :: bool +L47: + r132 = faster_hexbytes.main.HexBytes :: type return 1 -L8: - r26 = :: None - return r26 +L48: + r133 = :: None + return r133 +L49: + dec_ref r33 + goto L48 +L50: + dec_ref r33 + dec_ref r39 + goto L48 +L51: + dec_ref r61 + goto L48 +L52: + dec_ref r61 + dec_ref r73 + goto L48 +L53: + dec_ref r61 + dec_ref r73 + dec_ref r75 + goto L48 +L54: + dec_ref r61 + dec_ref r73 + dec_ref r75 + dec_ref r76 + goto L48 +L55: + dec_ref r116 + goto L48 From 14b36cea91b6c4f7d645b673c84599a0d5288dfc Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 15:21:31 -0400 Subject: [PATCH 56/70] fix: TypeError in `HexBytes.__new__` if called from subclass (#10) * Update main.py * Update main.py * chore: compile C files for source control * Create _helper.py * Update main.py * Update setup.py * chore: compile C files for source control * Delete build directory * chore: compile C files for source control * Update main.py * chore: compile C files for source control * Delete faster_hexbytes/_helper.py * chore: compile C files for source control * Update setup.py * chore: compile C files for source control * Update main.py * Delete build directory * chore: compile C files for source control --------- Co-authored-by: github-actions[bot] --- build/__native_6a32f4913d613d6a7ddf.c | 3043 ----------------- .../__native_internal_6a32f4913d613d6a7ddf.h | 5 +- build/ops.txt | 1229 +++++++ faster_hexbytes/main.py | 14 +- 4 files changed, 1246 insertions(+), 3045 deletions(-) diff --git a/build/__native_6a32f4913d613d6a7ddf.c b/build/__native_6a32f4913d613d6a7ddf.c index 2715d45..e69de29 100644 --- a/build/__native_6a32f4913d613d6a7ddf.c +++ b/build/__native_6a32f4913d613d6a7ddf.c @@ -1,3043 +0,0 @@ -#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[3]; /* '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[69]; /* ('version',) */ - cpy_r_r6 = CPyStatics[70]; /* ('__version',) */ - cpy_r_r7 = CPyStatics[6]; /* '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", "", 1, 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[71]; /* ('HexBytes',) */ - cpy_r_r11 = CPyStatics[8]; /* '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", "", 5, 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[7]; /* 'HexBytes' */ - cpy_r_r15 = PyList_New(1); - if (unlikely(cpy_r_r15 == NULL)) { - CPy_AddTraceback("faster_hexbytes/__init__.py", "", 9, 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[9]; /* '__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", "", 9, CPyStatic_faster_hexbytes___globals); - goto CPyL12; - } - cpy_r_r22 = CPyStatics[10]; /* 'hexbytes' */ - cpy_r_r23 = CPyStatic_faster_hexbytes___globals; - cpy_r_r24 = CPyStatics[5]; /* '__version' */ - cpy_r_r25 = CPyDict_GetItem(cpy_r_r23, cpy_r_r24); - if (unlikely(cpy_r_r25 == NULL)) { - CPy_AddTraceback("faster_hexbytes/__init__.py", "", 11, 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", "", 11, 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[11]; /* '__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", "", 11, 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", 21, 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", 23, 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", 25, CPyStatic__utils___globals); - goto CPyL51; - } - if (!cpy_r_r12) goto CPyL15; - cpy_r_r13 = CPyStatics[67]; /* b'\x01' */ - CPy_INCREF(cpy_r_r13); - cpy_r_r14 = cpy_r_r13; - goto CPyL16; -CPyL15: ; - cpy_r_r15 = CPyStatics[68]; /* 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", 29, 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[12]; /* '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", 30, 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", 30, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r28 = CPyStatics[13]; /* ' 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", 30, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r30 = CPyModule_builtins; - cpy_r_r31 = CPyStatics[14]; /* '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", 30, 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", 30, 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", 30, 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", 32, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r37 = CPyModule_builtins; - cpy_r_r38 = CPyStatics[15]; /* '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", 32, 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", 32, 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", 32, CPyStatic__utils___globals); - goto CPyL51; - } - return cpy_r_r45; -CPyL37: ; - cpy_r_r46 = CPyModule_builtins; - cpy_r_r47 = CPyStatics[16]; /* '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", 33, 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", 33, 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", 34, 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[17]; /* '' */ - cpy_r_r58 = CPyStatics[18]; /* 'Cannot convert ' */ - cpy_r_r59 = CPyStatics[19]; /* '{!r:{}}' */ - cpy_r_r60 = CPyStatics[17]; /* '' */ - cpy_r_r61 = CPyStatics[20]; /* '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", 36, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r65 = CPyStatics[21]; /* ' of type ' */ - cpy_r_r66 = CPyStatics[22]; /* '{:{}}' */ - cpy_r_r67 = CPy_TYPE(cpy_r_val); - cpy_r_r68 = CPyStatics[17]; /* '' */ - cpy_r_r69 = CPyStatics[20]; /* '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", 36, CPyStatic__utils___globals); - goto CPyL55; - } - CPy_DECREF(cpy_r_r67); - cpy_r_r73 = CPyStatics[13]; /* ' to bytes' */ - cpy_r_r74 = PyList_New(5); - if (unlikely(cpy_r_r74 == NULL)) { - CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 36, 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", 36, CPyStatic__utils___globals); - goto CPyL51; - } - cpy_r_r82 = CPyModule_builtins; - cpy_r_r83 = CPyStatics[23]; /* '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", 36, 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", 36, 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", 36, 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", 11, 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[24]; /* '0x' */ - cpy_r_r1 = CPyStatics[25]; /* '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", 40, 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", 41, 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", 46, 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", 46, 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[26]; /* '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", 47, 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", 52, 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[27]; /* '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", 53, 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[28]; /* 'hex string ' */ - cpy_r_r21 = CPyStatics[29]; /* ' 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", 55, CPyStatic__utils___globals); - goto CPyL23; - } - cpy_r_r23 = CPyModule_builtins; - cpy_r_r24 = CPyStatics[14]; /* '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", 54, 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", 54, 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", 54, 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", 58, 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", 58, 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", 39, 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[3]; /* '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[73]; /* (('binascii', 'binascii', 'binascii'),) */ - cpy_r_r11 = CPyStatic__utils___globals; - cpy_r_r12 = CPyStatics[31]; /* 'faster_hexbytes/_utils.py' */ - cpy_r_r13 = CPyStatics[32]; /* '' */ - 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[74]; /* ('Final', 'Union') */ - cpy_r_r16 = CPyStatics[35]; /* '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", "", 2, 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[36]; /* 'unhexlify' */ - cpy_r_r21 = CPyObject_GetAttr(cpy_r_r19, cpy_r_r20); - if (unlikely(cpy_r_r21 == NULL)) { - CPy_AddTraceback("faster_hexbytes/_utils.py", "", 8, 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[36]; /* '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", "", 8, 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_____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__", 49, 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__", 50, 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__", 50, CPyStatic_main___globals); - goto CPyL9; - } - CPy_DECREF(cpy_r_r0); - if (likely(Py_TYPE(cpy_r_r5) == CPyType_main___HexBytes)) - cpy_r_r6 = cpy_r_r5; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__new__", 50, 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__", 48, 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[37]; /* '__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__", 63, 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__", 63, 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__", 65, 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__", 69, 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__", 69, CPyStatic_main___globals); - goto CPyL16; - } - CPy_DECREF(cpy_r_r12); - if (likely(Py_TYPE(cpy_r_r16) == CPyType_main___HexBytes)) - cpy_r_r17 = cpy_r_r16; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 69, 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__", 70, 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__", 70, CPyStatic_main___globals); - goto CPyL18; - } - CPy_DECREF(cpy_r_r18); - if (likely(Py_TYPE(cpy_r_r21) == CPyType_main___HexBytes)) - cpy_r_r22 = cpy_r_r21; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__getitem__", 70, 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(Py_TYPE(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__", 60, 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[38]; /* "HexBytes('0x" */ - cpy_r_r1 = CPyStatics[15]; /* '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__", 73, 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__", 73, CPyStatic_main___globals, "str", cpy_r_r4); - goto CPyL4; - } - cpy_r_r6 = CPyStatics[39]; /* "')" */ - 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__", 73, 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(Py_TYPE(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__", 72, 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[24]; /* '0x' */ - cpy_r_r1 = CPyStatics[15]; /* '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", 79, 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", 79, 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", 79, 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(Py_TYPE(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", 75, 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__", 89, 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__", 89, 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__", 89, 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(Py_TYPE(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__", 81, 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_r122; - PyObject *cpy_r_r123; - PyObject *cpy_r_r124; - PyObject **cpy_r_r126; - PyObject *cpy_r_r127; - PyObject *cpy_r_r128; - PyObject *cpy_r_r129; - int32_t cpy_r_r130; - char cpy_r_r131; - PyObject *cpy_r_r132; - char cpy_r_r133; - 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[3]; /* '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 CPyL48; - } - CPyModule_builtins = cpy_r_r4; - CPy_INCREF(CPyModule_builtins); - CPy_DECREF(cpy_r_r4); -CPyL3: ; - cpy_r_r5 = CPyStatics[75]; /* ('TYPE_CHECKING', 'Callable', 'Final', 'Tuple', 'Type', - 'Union', 'overload') */ - cpy_r_r6 = CPyStatics[35]; /* '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", "", 1, CPyStatic_main___globals); - goto CPyL48; - } - 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[77]; /* (('hexbytes.main', 'hexbytes.main', 'hexbytes'),) */ - cpy_r_r15 = CPyStatic_main___globals; - cpy_r_r16 = CPyStatics[46]; /* 'faster_hexbytes/main.py' */ - cpy_r_r17 = CPyStatics[32]; /* '' */ - 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 CPyL48; - cpy_r_r19 = CPyStatics[78]; /* ('mypyc_attr',) */ - cpy_r_r20 = CPyStatics[48]; /* '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", "", 15, CPyStatic_main___globals); - goto CPyL48; - } - CPyModule_mypy_extensions = cpy_r_r22; - CPy_INCREF(CPyModule_mypy_extensions); - CPy_DECREF(cpy_r_r22); - cpy_r_r23 = CPyStatics[79]; /* ('Self',) */ - cpy_r_r24 = CPyStatics[50]; /* '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", "", 18, CPyStatic_main___globals); - goto CPyL48; - } - CPyModule_typing_extensions = cpy_r_r26; - CPy_INCREF(CPyModule_typing_extensions); - CPy_DECREF(cpy_r_r26); - cpy_r_r27 = CPyStatics[80]; /* ('to_bytes',) */ - cpy_r_r28 = CPyStatics[52]; /* '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", "", 22, CPyStatic_main___globals); - goto CPyL48; - } - 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[34]; /* 'Union' */ - cpy_r_r33 = CPyDict_GetItem(cpy_r_r31, cpy_r_r32); - if (unlikely(cpy_r_r33 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 31, CPyStatic_main___globals); - goto CPyL48; - } - 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[53]; /* 'bytearray' */ - cpy_r_r39 = CPyObject_GetAttr(cpy_r_r37, cpy_r_r38); - if (unlikely(cpy_r_r39 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 31, CPyStatic_main___globals); - goto CPyL49; - } - cpy_r_r40 = (PyObject *)&PyLong_Type; - cpy_r_r41 = CPyModule_builtins; - cpy_r_r42 = CPyStatics[16]; /* 'memoryview' */ - cpy_r_r43 = CPyObject_GetAttr(cpy_r_r41, cpy_r_r42); - if (unlikely(cpy_r_r43 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 31, CPyStatic_main___globals); - goto CPyL50; - } - 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", "", 31, CPyStatic_main___globals); - goto CPyL48; - } - cpy_r_r47 = CPyStatic_main___globals; - cpy_r_r48 = CPyStatics[54]; /* '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", "", 31, CPyStatic_main___globals); - goto CPyL48; - } - cpy_r_r51 = (PyObject *)&PyBytes_Type; - cpy_r_r52 = CPyStatics[55]; /* '__new__' */ - cpy_r_r53 = CPyObject_GetAttr(cpy_r_r51, cpy_r_r52); - if (unlikely(cpy_r_r53 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 33, CPyStatic_main___globals); - goto CPyL48; - } - CPyStatic_main____bytes_new = cpy_r_r53; - CPy_INCREF(CPyStatic_main____bytes_new); - cpy_r_r54 = CPyStatic_main___globals; - cpy_r_r55 = CPyStatics[56]; /* '_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", "", 33, CPyStatic_main___globals); - goto CPyL48; - } - cpy_r_r58 = CPyModule_hexbytes___main; - cpy_r_r59 = CPyStatics[7]; /* 'HexBytes' */ - cpy_r_r60 = CPyObject_GetAttr(cpy_r_r58, cpy_r_r59); - if (unlikely(cpy_r_r60 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); - goto CPyL48; - } - 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", "", 37, CPyStatic_main___globals); - goto CPyL48; - } - 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", "", 37, CPyStatic_main___globals); - goto CPyL51; - } - cpy_r_r64 = CPyStatics[57]; /* '__prepare__' */ - cpy_r_r65 = PyObject_HasAttr(cpy_r_r63, cpy_r_r64); - if (!cpy_r_r65) goto CPyL24; - cpy_r_r66 = CPyStatics[7]; /* 'HexBytes' */ - cpy_r_r67 = CPyStatics[57]; /* '__prepare__' */ - cpy_r_r68 = CPyObject_GetAttr(cpy_r_r63, cpy_r_r67); - if (unlikely(cpy_r_r68 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); - goto CPyL51; - } - 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", "", 37, CPyStatic_main___globals); - goto CPyL51; - } - if (likely(PyDict_Check(cpy_r_r71))) - cpy_r_r72 = cpy_r_r71; - else { - CPy_TypeErrorTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals, "dict", cpy_r_r71); - goto CPyL51; - } - 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", "", 37, CPyStatic_main___globals); - goto CPyL51; - } - cpy_r_r73 = cpy_r_r74; -CPyL26: ; - cpy_r_r75 = PyDict_New(); - if (unlikely(cpy_r_r75 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); - goto CPyL52; - } - cpy_r_r76 = CPyDef_main_____new___3_HexBytes_obj(); - if (unlikely(cpy_r_r76 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 48, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r77 = CPyModule_builtins; - cpy_r_r78 = CPyStatics[58]; /* 'staticmethod' */ - cpy_r_r79 = CPyObject_GetAttr(cpy_r_r77, cpy_r_r78); - if (unlikely(cpy_r_r79 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 48, CPyStatic_main___globals); - goto CPyL54; - } - 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", "", 48, CPyStatic_main___globals); - goto CPyL54; - } - CPy_DECREF_NO_IMM(cpy_r_r76); - cpy_r_r83 = CPyStatics[55]; /* '__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", "", 48, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r86 = CPyDef_main_____getitem___3_HexBytes_obj(); - if (unlikely(cpy_r_r86 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 60, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r87 = CPyStatics[37]; /* '__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", "", 60, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r90 = CPyDef_main_____repr___3_HexBytes_obj(); - if (unlikely(cpy_r_r90 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 72, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r91 = CPyStatics[59]; /* '__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", "", 72, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r94 = CPyDef_main___to_0x_hex_HexBytes_obj(); - if (unlikely(cpy_r_r94 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 75, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r95 = CPyStatics[60]; /* '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", "", 75, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r98 = CPyDef_main_____reduce___3_HexBytes_obj(); - if (unlikely(cpy_r_r98 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 81, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r99 = CPyStatics[61]; /* '__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", "", 81, CPyStatic_main___globals); - goto CPyL53; - } - cpy_r_r102 = CPyStatics[7]; /* 'HexBytes' */ - cpy_r_r103 = CPyStatics[62]; /* '__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", "", 37, CPyStatic_main___globals); - goto CPyL52; - } - cpy_r_r106 = CPyStatics[63]; /* 'mypyc filler docstring' */ - cpy_r_r107 = CPyStatics[64]; /* '__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", "", 37, CPyStatic_main___globals); - goto CPyL52; - } - cpy_r_r110 = CPyStatics[8]; /* 'faster_hexbytes.main' */ - cpy_r_r111 = CPyStatics[65]; /* '__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", "", 37, CPyStatic_main___globals); - goto CPyL52; - } - 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", "", 37, CPyStatic_main___globals); - goto CPyL52; - } - CPy_DECREF(cpy_r_r73); - CPy_DECREF(cpy_r_r61); - cpy_r_r117 = CPyStatic_main___globals; - cpy_r_r118 = CPyStatics[47]; /* '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", "", 36, CPyStatic_main___globals); - goto CPyL55; - } - cpy_r_r120 = 0 ? Py_True : Py_False; - PyObject *cpy_r_r121[1] = {cpy_r_r120}; - cpy_r_r122 = (PyObject **)&cpy_r_r121; - cpy_r_r123 = CPyStatics[81]; /* ('native_class',) */ - cpy_r_r124 = PyObject_Vectorcall(cpy_r_r119, cpy_r_r122, 0, cpy_r_r123); - CPy_DECREF(cpy_r_r119); - if (unlikely(cpy_r_r124 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 36, CPyStatic_main___globals); - goto CPyL55; - } - PyObject *cpy_r_r125[1] = {cpy_r_r116}; - cpy_r_r126 = (PyObject **)&cpy_r_r125; - cpy_r_r127 = PyObject_Vectorcall(cpy_r_r124, cpy_r_r126, 1, 0); - CPy_DECREF(cpy_r_r124); - if (unlikely(cpy_r_r127 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); - goto CPyL55; - } - CPy_DECREF(cpy_r_r116); - CPyType_main___HexBytes = (PyTypeObject *)cpy_r_r127; - CPy_INCREF(CPyType_main___HexBytes); - cpy_r_r128 = CPyStatic_main___globals; - cpy_r_r129 = CPyStatics[7]; /* 'HexBytes' */ - cpy_r_r130 = PyDict_SetItem(cpy_r_r128, cpy_r_r129, cpy_r_r127); - CPy_DECREF(cpy_r_r127); - cpy_r_r131 = cpy_r_r130 >= 0; - if (unlikely(!cpy_r_r131)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 37, CPyStatic_main___globals); - goto CPyL48; - } - cpy_r_r132 = (PyObject *)CPyType_main___HexBytes; - return 1; -CPyL48: ; - cpy_r_r133 = 2; - return cpy_r_r133; -CPyL49: ; - CPy_DecRef(cpy_r_r33); - goto CPyL48; -CPyL50: ; - CPy_DecRef(cpy_r_r33); - CPy_DecRef(cpy_r_r39); - goto CPyL48; -CPyL51: ; - CPy_DecRef(cpy_r_r61); - goto CPyL48; -CPyL52: ; - CPy_DecRef(cpy_r_r61); - CPy_DecRef(cpy_r_r73); - goto CPyL48; -CPyL53: ; - CPy_DecRef(cpy_r_r61); - CPy_DecRef(cpy_r_r73); - CPy_DecRef(cpy_r_r75); - goto CPyL48; -CPyL54: ; - CPy_DecRef(cpy_r_r61); - CPy_DecRef(cpy_r_r73); - CPy_DecRef(cpy_r_r75); - CPy_DecRef(cpy_r_r76); - goto CPyL48; -CPyL55: ; - CPy_DecRef(cpy_r_r116); - goto CPyL48; -} - -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[82]; -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__", - "\001\fnative_class", - "", -}; -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[] = { - 13, 1, 4, 1, 5, 1, 7, 3, 30, 30, 30, 1, 72, 2, 33, 34, 7, 40, 41, - 33, 42, 43, 34, 44, 3, 45, 45, 10, 1, 76, 1, 47, 1, 49, 1, 51, 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_____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_internal_6a32f4913d613d6a7ddf.h b/build/__native_internal_6a32f4913d613d6a7ddf.h index 84b1a09..a093531 100644 --- a/build/__native_internal_6a32f4913d613d6a7ddf.h +++ b/build/__native_internal_6a32f4913d613d6a7ddf.h @@ -6,7 +6,7 @@ int CPyGlobalsInit(void); -extern PyObject *CPyStatics[82]; +extern PyObject *CPyStatics[87]; extern const char * const CPyLit_Str[]; extern const char * const CPyLit_Bytes[]; extern const char * const CPyLit_Int[]; @@ -39,6 +39,9 @@ extern PyObject *CPyPy__utils___hexstr_to_bytes(PyObject *self, PyObject *const 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; diff --git a/build/ops.txt b/build/ops.txt index 390263a..00e1254 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -572,6 +572,1235 @@ L8: r26 = :: None return r26 +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, r2, r3, r4 :: str + r5 :: object[1] + r6 :: object_ptr + r7 :: object + r8, r9, r10, r11 :: str + r12 :: object[3] + r13 :: object_ptr + r14 :: object + r15, r16 :: str + r17 :: list + r18, r19, r20, r21 :: ptr + r22, r23 :: str +L0: + r0 = '' + r1 = 'HexBytes(' + r2 = '{!r:{}}' + r3 = '0x' + r4 = 'hex' + r5 = [self] + r6 = load_address r5 + r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) + if is_error(r7) goto L8 (error at __repr__:74) else goto L1 +L1: + r8 = cast(str, r7) + if is_error(r8) goto L8 (error at __repr__:74) else goto L2 +L2: + r9 = PyUnicode_Concat(r3, r8) + dec_ref r8 + if is_error(r9) goto L8 (error at __repr__:74) else goto L3 +L3: + r10 = '' + r11 = 'format' + r12 = [r2, r9, r10] + r13 = load_address r12 + r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) + if is_error(r14) goto L9 (error at __repr__:74) else goto L4 +L4: + dec_ref r9 + r15 = cast(str, r14) + if is_error(r15) goto L8 (error at __repr__:74) else goto L5 +L5: + r16 = ')' + r17 = PyList_New(3) + if is_error(r17) goto L10 (error at __repr__:74) else goto L6 +L6: + r18 = get_element_ptr r17 ob_item :: PyListObject + r19 = load_mem r18 :: ptr* + inc_ref r1 + set_mem r19, r1 :: builtins.object* + r20 = r19 + 8 + set_mem r20, r15 :: builtins.object* + inc_ref r16 + r21 = r19 + 16 + set_mem r21, r16 :: builtins.object* + r22 = PyUnicode_Join(r0, r17) + dec_ref r17 + if is_error(r22) goto L8 (error at __repr__:74) else goto L7 +L7: + return r22 +L8: + r23 = :: str + return r23 +L9: + dec_ref r9 + goto L8 +L10: + dec_ref r15 + goto L8 + +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 diff --git a/faster_hexbytes/main.py b/faster_hexbytes/main.py index 8cbc5c2..774cd23 100644 --- a/faster_hexbytes/main.py +++ b/faster_hexbytes/main.py @@ -28,12 +28,13 @@ SupportsIndex, ) + BytesLike = Union[bytes, str, bool, bytearray, int, memoryview] _bytes_new: Final = bytes.__new__ -@mypyc_attr(native_class=False) +@mypyc_attr(native_class=False, allow_interpreted_subclasses=True) class HexBytes(hexbytes.HexBytes): """ Thin wrapper around the python built-in :class:`bytes` class. @@ -87,3 +88,14 @@ def __reduce__( 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): ... From 56ac7cb8d77bc7915b3f5474b0eabec4e49df562 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 15:23:44 -0400 Subject: [PATCH 57/70] chore: bump version to 1.3.2 --- setup.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 9df5152..11dc299 100644 --- a/setup.py +++ b/setup.py @@ -7,7 +7,8 @@ from mypyc.build import mypycify -version = "1.3.1" +version = "1.3.2" +hexbytes_version = "1.3.1" extras_require = { "dev": [ @@ -61,7 +62,7 @@ author_email="snakecharmers@ethereum.org", url="https://github.com/ethereum/hexbytes", include_package_data=True, - install_requires=[f"hexbytes=={version}", "mypy_extensions"], + install_requires=[f"hexbytes=={hexbytes_version}", "mypy_extensions"], python_requires=">=3.9, <4", extras_require=extras_require, py_modules=["faster_hexbytes"], From a68fc534bbbe26cdc9c38927b72263d0be92579d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 19:30:54 +0000 Subject: [PATCH 58/70] chore: compile C files for source control --- build/__native_6a32f4913d613d6a7ddf.c | 3608 +++++++++++++++++++++++++ build/ops.txt | 2250 +++++---------- 2 files changed, 4338 insertions(+), 1520 deletions(-) diff --git a/build/__native_6a32f4913d613d6a7ddf.c b/build/__native_6a32f4913d613d6a7ddf.c index e69de29..5effd18 100644 --- a/build/__native_6a32f4913d613d6a7ddf.c +++ b/build/__native_6a32f4913d613d6a7ddf.c @@ -0,0 +1,3608 @@ +#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[3]; /* '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[73]; /* ('version',) */ + cpy_r_r6 = CPyStatics[74]; /* ('__version',) */ + cpy_r_r7 = CPyStatics[6]; /* '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", "", 1, 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[75]; /* ('HexBytes',) */ + cpy_r_r11 = CPyStatics[8]; /* '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", "", 5, 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[7]; /* 'HexBytes' */ + cpy_r_r15 = PyList_New(1); + if (unlikely(cpy_r_r15 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", 9, 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[9]; /* '__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", "", 9, CPyStatic_faster_hexbytes___globals); + goto CPyL12; + } + cpy_r_r22 = CPyStatics[10]; /* 'hexbytes' */ + cpy_r_r23 = CPyStatic_faster_hexbytes___globals; + cpy_r_r24 = CPyStatics[5]; /* '__version' */ + cpy_r_r25 = CPyDict_GetItem(cpy_r_r23, cpy_r_r24); + if (unlikely(cpy_r_r25 == NULL)) { + CPy_AddTraceback("faster_hexbytes/__init__.py", "", 11, 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", "", 11, 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[11]; /* '__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", "", 11, 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", 21, 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", 23, 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", 25, CPyStatic__utils___globals); + goto CPyL51; + } + if (!cpy_r_r12) goto CPyL15; + cpy_r_r13 = CPyStatics[71]; /* b'\x01' */ + CPy_INCREF(cpy_r_r13); + cpy_r_r14 = cpy_r_r13; + goto CPyL16; +CPyL15: ; + cpy_r_r15 = CPyStatics[72]; /* 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", 29, 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[12]; /* '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", 30, 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", 30, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r28 = CPyStatics[13]; /* ' 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", 30, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r30 = CPyModule_builtins; + cpy_r_r31 = CPyStatics[14]; /* '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", 30, 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", 30, 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", 30, 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", 32, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r37 = CPyModule_builtins; + cpy_r_r38 = CPyStatics[15]; /* '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", 32, 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", 32, 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", 32, CPyStatic__utils___globals); + goto CPyL51; + } + return cpy_r_r45; +CPyL37: ; + cpy_r_r46 = CPyModule_builtins; + cpy_r_r47 = CPyStatics[16]; /* '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", 33, 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", 33, 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", 34, 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[17]; /* '' */ + cpy_r_r58 = CPyStatics[18]; /* 'Cannot convert ' */ + cpy_r_r59 = CPyStatics[19]; /* '{!r:{}}' */ + cpy_r_r60 = CPyStatics[17]; /* '' */ + cpy_r_r61 = CPyStatics[20]; /* '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", 36, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r65 = CPyStatics[21]; /* ' of type ' */ + cpy_r_r66 = CPyStatics[22]; /* '{:{}}' */ + cpy_r_r67 = CPy_TYPE(cpy_r_val); + cpy_r_r68 = CPyStatics[17]; /* '' */ + cpy_r_r69 = CPyStatics[20]; /* '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", 36, CPyStatic__utils___globals); + goto CPyL55; + } + CPy_DECREF(cpy_r_r67); + cpy_r_r73 = CPyStatics[13]; /* ' to bytes' */ + cpy_r_r74 = PyList_New(5); + if (unlikely(cpy_r_r74 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 36, 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", 36, CPyStatic__utils___globals); + goto CPyL51; + } + cpy_r_r82 = CPyModule_builtins; + cpy_r_r83 = CPyStatics[23]; /* '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", 36, 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", 36, 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", 36, 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", 11, 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[24]; /* '0x' */ + cpy_r_r1 = CPyStatics[25]; /* '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", 40, 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", 41, 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", 46, 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", 46, 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[26]; /* '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", 47, 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", 52, 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[27]; /* '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", 53, 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[28]; /* 'hex string ' */ + cpy_r_r21 = CPyStatics[29]; /* ' 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", 55, CPyStatic__utils___globals); + goto CPyL23; + } + cpy_r_r23 = CPyModule_builtins; + cpy_r_r24 = CPyStatics[14]; /* '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", 54, 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", 54, 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", 54, 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", 58, 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", 58, 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", 39, 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[3]; /* '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[77]; /* (('binascii', 'binascii', 'binascii'),) */ + cpy_r_r11 = CPyStatic__utils___globals; + cpy_r_r12 = CPyStatics[31]; /* 'faster_hexbytes/_utils.py' */ + cpy_r_r13 = CPyStatics[32]; /* '' */ + 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[78]; /* ('Final', 'Union') */ + cpy_r_r16 = CPyStatics[35]; /* '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", "", 2, 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[36]; /* 'unhexlify' */ + cpy_r_r21 = CPyObject_GetAttr(cpy_r_r19, cpy_r_r20); + if (unlikely(cpy_r_r21 == NULL)) { + CPy_AddTraceback("faster_hexbytes/_utils.py", "", 8, 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[36]; /* '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", "", 8, 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__", 50, 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__", 51, 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__", 51, 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__", 49, 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[37]; /* '__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__", 64, 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__", 66, 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__", 70, 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__", 71, 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__", 61, 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[38]; /* "HexBytes('0x" */ + cpy_r_r1 = CPyStatics[15]; /* '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__", 74, 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[39]; /* "')" */ + 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__", 74, 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__", 73, 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[24]; /* '0x' */ + cpy_r_r1 = CPyStatics[15]; /* '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", 80, 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", 80, 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", 76, 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__", 90, 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__", 90, 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__", 82, 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[3]; /* '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[79]; /* ('TYPE_CHECKING', 'Callable', 'Final', 'Tuple', 'Type', + 'Union', 'overload') */ + cpy_r_r6 = CPyStatics[35]; /* '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", "", 1, 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[81]; /* (('hexbytes.main', 'hexbytes.main', 'hexbytes'),) */ + cpy_r_r15 = CPyStatic_main___globals; + cpy_r_r16 = CPyStatics[46]; /* 'faster_hexbytes/main.py' */ + cpy_r_r17 = CPyStatics[32]; /* '' */ + 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[82]; /* ('mypyc_attr',) */ + cpy_r_r20 = CPyStatics[48]; /* '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", "", 15, 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[83]; /* ('Self',) */ + cpy_r_r24 = CPyStatics[50]; /* '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", "", 18, 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[84]; /* ('to_bytes',) */ + cpy_r_r28 = CPyStatics[52]; /* '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", "", 22, 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[34]; /* 'Union' */ + cpy_r_r33 = CPyDict_GetItem(cpy_r_r31, cpy_r_r32); + if (unlikely(cpy_r_r33 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 32, 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[53]; /* 'bytearray' */ + cpy_r_r39 = CPyObject_GetAttr(cpy_r_r37, cpy_r_r38); + if (unlikely(cpy_r_r39 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 32, CPyStatic_main___globals); + goto CPyL106; + } + cpy_r_r40 = (PyObject *)&PyLong_Type; + cpy_r_r41 = CPyModule_builtins; + cpy_r_r42 = CPyStatics[16]; /* 'memoryview' */ + cpy_r_r43 = CPyObject_GetAttr(cpy_r_r41, cpy_r_r42); + if (unlikely(cpy_r_r43 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 32, 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", "", 32, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r47 = CPyStatic_main___globals; + cpy_r_r48 = CPyStatics[54]; /* '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", "", 32, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r51 = (PyObject *)&PyBytes_Type; + cpy_r_r52 = CPyStatics[55]; /* '__new__' */ + cpy_r_r53 = CPyObject_GetAttr(cpy_r_r51, cpy_r_r52); + if (unlikely(cpy_r_r53 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 34, 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[56]; /* '_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", "", 34, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r58 = CPyModule_hexbytes___main; + cpy_r_r59 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r60 = CPyObject_GetAttr(cpy_r_r58, cpy_r_r59); + if (unlikely(cpy_r_r60 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 38, 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", "", 38, 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", "", 38, CPyStatic_main___globals); + goto CPyL108; + } + cpy_r_r64 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r65 = PyObject_HasAttr(cpy_r_r63, cpy_r_r64); + if (!cpy_r_r65) goto CPyL24; + cpy_r_r66 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r67 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r68 = CPyObject_GetAttr(cpy_r_r63, cpy_r_r67); + if (unlikely(cpy_r_r68 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 38, 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", "", 38, 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", "", 38, 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", "", 38, 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", "", 49, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r77 = CPyModule_builtins; + cpy_r_r78 = CPyStatics[58]; /* 'staticmethod' */ + cpy_r_r79 = CPyObject_GetAttr(cpy_r_r77, cpy_r_r78); + if (unlikely(cpy_r_r79 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 49, 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", "", 49, CPyStatic_main___globals); + goto CPyL111; + } + CPy_DECREF_NO_IMM(cpy_r_r76); + cpy_r_r83 = CPyStatics[55]; /* '__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", "", 49, 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", "", 61, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r87 = CPyStatics[37]; /* '__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", "", 61, 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", "", 73, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r91 = CPyStatics[59]; /* '__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", "", 73, 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", "", 76, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r95 = CPyStatics[60]; /* '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", "", 76, 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", "", 82, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r99 = CPyStatics[61]; /* '__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", "", 82, CPyStatic_main___globals); + goto CPyL110; + } + cpy_r_r102 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r103 = CPyStatics[62]; /* '__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", "", 38, CPyStatic_main___globals); + goto CPyL109; + } + cpy_r_r106 = CPyStatics[63]; /* 'mypyc filler docstring' */ + cpy_r_r107 = CPyStatics[64]; /* '__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", "", 38, CPyStatic_main___globals); + goto CPyL109; + } + cpy_r_r110 = CPyStatics[8]; /* 'faster_hexbytes.main' */ + cpy_r_r111 = CPyStatics[65]; /* '__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", "", 38, 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", "", 38, 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[47]; /* '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", "", 37, 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[85]; /* ('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", "", 37, 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", "", 38, 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[7]; /* '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", "", 38, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r133 = (PyObject *)CPyType_main___HexBytes; + cpy_r_r134 = CPyStatic_main___globals; + cpy_r_r135 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r136 = CPyDict_GetItem(cpy_r_r134, cpy_r_r135); + if (unlikely(cpy_r_r136 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 97, 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", "", 97, 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", "", 97, CPyStatic_main___globals); + goto CPyL113; + } + cpy_r_r140 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r141 = PyObject_HasAttr(cpy_r_r139, cpy_r_r140); + if (!cpy_r_r141) goto CPyL55; + cpy_r_r142 = CPyStatics[68]; /* '_HexBytesSubclass1' */ + cpy_r_r143 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r144 = CPyObject_GetAttr(cpy_r_r139, cpy_r_r143); + if (unlikely(cpy_r_r144 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 97, 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", "", 97, 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", "", 97, 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", "", 97, CPyStatic_main___globals); + goto CPyL114; + } + cpy_r_r152 = CPyStatics[68]; /* '_HexBytesSubclass1' */ + cpy_r_r153 = CPyStatics[62]; /* '__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", "", 97, CPyStatic_main___globals); + goto CPyL114; + } + cpy_r_r156 = CPyStatics[63]; /* 'mypyc filler docstring' */ + cpy_r_r157 = CPyStatics[64]; /* '__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", "", 97, CPyStatic_main___globals); + goto CPyL114; + } + cpy_r_r160 = CPyStatics[8]; /* 'faster_hexbytes.main' */ + cpy_r_r161 = CPyStatics[65]; /* '__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", "", 97, 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", "", 97, 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[47]; /* '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", "", 96, 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[86]; /* ('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", "", 96, 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", "", 97, 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[68]; /* '_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", "", 97, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r182 = (PyObject *)CPyType_main____HexBytesSubclass1; + cpy_r_r183 = CPyStatic_main___globals; + cpy_r_r184 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r185 = CPyDict_GetItem(cpy_r_r183, cpy_r_r184); + if (unlikely(cpy_r_r185 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 99, 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", "", 99, 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", "", 99, CPyStatic_main___globals); + goto CPyL116; + } + cpy_r_r189 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r190 = PyObject_HasAttr(cpy_r_r188, cpy_r_r189); + if (!cpy_r_r190) goto CPyL74; + cpy_r_r191 = CPyStatics[69]; /* '_HexBytesSubclass2' */ + cpy_r_r192 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r193 = CPyObject_GetAttr(cpy_r_r188, cpy_r_r192); + if (unlikely(cpy_r_r193 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 99, 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", "", 99, 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", "", 99, 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", "", 99, CPyStatic_main___globals); + goto CPyL117; + } + cpy_r_r201 = CPyStatics[69]; /* '_HexBytesSubclass2' */ + cpy_r_r202 = CPyStatics[62]; /* '__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", "", 99, CPyStatic_main___globals); + goto CPyL117; + } + cpy_r_r205 = CPyStatics[63]; /* 'mypyc filler docstring' */ + cpy_r_r206 = CPyStatics[64]; /* '__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", "", 99, CPyStatic_main___globals); + goto CPyL117; + } + cpy_r_r209 = CPyStatics[8]; /* 'faster_hexbytes.main' */ + cpy_r_r210 = CPyStatics[65]; /* '__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", "", 99, 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", "", 99, 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[47]; /* '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", "", 98, 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[86]; /* ('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", "", 98, 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", "", 99, 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[69]; /* '_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", "", 99, CPyStatic_main___globals); + goto CPyL105; + } + cpy_r_r231 = (PyObject *)CPyType_main____HexBytesSubclass2; + cpy_r_r232 = CPyStatic_main___globals; + cpy_r_r233 = CPyStatics[7]; /* 'HexBytes' */ + cpy_r_r234 = CPyDict_GetItem(cpy_r_r232, cpy_r_r233); + if (unlikely(cpy_r_r234 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 101, 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", "", 101, 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", "", 101, CPyStatic_main___globals); + goto CPyL119; + } + cpy_r_r238 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r239 = PyObject_HasAttr(cpy_r_r237, cpy_r_r238); + if (!cpy_r_r239) goto CPyL93; + cpy_r_r240 = CPyStatics[70]; /* '_HexBytesSubclass3' */ + cpy_r_r241 = CPyStatics[57]; /* '__prepare__' */ + cpy_r_r242 = CPyObject_GetAttr(cpy_r_r237, cpy_r_r241); + if (unlikely(cpy_r_r242 == NULL)) { + CPy_AddTraceback("faster_hexbytes/main.py", "", 101, 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", "", 101, 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", "", 101, 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", "", 101, CPyStatic_main___globals); + goto CPyL120; + } + cpy_r_r250 = CPyStatics[70]; /* '_HexBytesSubclass3' */ + cpy_r_r251 = CPyStatics[62]; /* '__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", "", 101, CPyStatic_main___globals); + goto CPyL120; + } + cpy_r_r254 = CPyStatics[63]; /* 'mypyc filler docstring' */ + cpy_r_r255 = CPyStatics[64]; /* '__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", "", 101, CPyStatic_main___globals); + goto CPyL120; + } + cpy_r_r258 = CPyStatics[8]; /* 'faster_hexbytes.main' */ + cpy_r_r259 = CPyStatics[65]; /* '__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", "", 101, 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", "", 101, 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[47]; /* '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", "", 100, 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[86]; /* ('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", "", 100, 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", "", 101, 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[70]; /* '_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", "", 101, 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[87]; +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/ops.txt b/build/ops.txt index 00e1254..8dfadfc 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,740 +1,166 @@ -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 +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 :: 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 + 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 = PyBytes_Check(val) - if r0 goto L1 else goto L3 :: bool + 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: - inc_ref val - r1 = cast(bytes, val) - if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 + r5 = cast(union[int, bytes], r4) + if is_error(r5) goto L14 (error at __getitem__:64) else goto L2 L2: - return r1 + r6 = PyLong_Check(r5) + if r6 goto L3 else goto L5 :: bool L3: - r2 = PyUnicode_Check(val) - if r2 goto L4 else goto L7 :: bool + r7 = unbox(int, r5) + dec_ref r5 + if is_error(r7) goto L14 (error at __getitem__:66) else goto L4 L4: - inc_ref val - r3 = cast(str, val) - if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 + r8 = box(int, r7) + return r8 L5: - r4 = hexstr_to_bytes(r3) - dec_ref r3 - if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 + r9 = CPy_TYPE(self) + r10 = faster_hexbytes.main.HexBytes :: type + r11 = r9 == r10 + if r11 goto L15 else goto L10 :: bool L6: - return r4 + r12 = cast(bytes, r5) + if is_error(r12) goto L14 (error at __getitem__:70) else goto L7 L7: - r5 = PyByteArray_Check(val) - if r5 goto L8 else goto L11 :: bool + 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: - 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 + dec_ref r12 + r17 = cast(faster_hexbytes.main.HexBytes, r16) + if is_error(r17) goto L14 (error at __getitem__:70) else goto L9 L9: - r10 = cast(bytes, r9) - if is_error(r10) goto L51 (error at to_bytes:23) else goto L10 + return r17 L10: - return r10 + r18 = cast(bytes, r5) + if is_error(r18) goto L17 (error at __getitem__:71) else goto L11 L11: - r11 = PyBool_Check(val) - if r11 goto L12 else goto L17 :: bool + 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: - r12 = unbox(bool, val) - if is_error(r12) goto L51 (error at to_bytes:25) else goto L13 + dec_ref r18 + r22 = cast(faster_hexbytes.main.HexBytes, r21) + if is_error(r22) goto L14 (error at __getitem__:71) 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 - -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 + return r22 L14: r23 = :: union[int, faster_hexbytes.main.HexBytes] return r23 @@ -774,74 +200,31 @@ L4: def __repr___HexBytes_obj.__call__(__mypyc_self__, self): __mypyc_self__ :: faster_hexbytes.main.__repr___HexBytes_obj self :: faster_hexbytes.main.HexBytes - r0, r1, r2, r3, r4 :: str - r5 :: object[1] - r6 :: object_ptr - r7 :: object - r8, r9, r10, r11 :: str - r12 :: object[3] - r13 :: object_ptr - r14 :: object - r15, r16 :: str - r17 :: list - r18, r19, r20, r21 :: ptr - r22, r23 :: str + r0, r1 :: str + r2 :: object[1] + r3 :: object_ptr + r4 :: object + r5, r6, r7, r8 :: str L0: - r0 = '' - r1 = 'HexBytes(' - r2 = '{!r:{}}' - r3 = '0x' - r4 = 'hex' - r5 = [self] - r6 = load_address r5 - r7 = PyObject_VectorcallMethod(r4, r6, 9223372036854775809, 0) - if is_error(r7) goto L8 (error at __repr__:74) else goto L1 + 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: - r8 = cast(str, r7) - if is_error(r8) goto L8 (error at __repr__:74) else goto L2 + r5 = cast(str, r4) + if is_error(r5) goto L4 (error at __repr__:74) else goto L2 L2: - r9 = PyUnicode_Concat(r3, r8) - dec_ref r8 - if is_error(r9) goto L8 (error at __repr__:74) else goto L3 + 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: - r10 = '' - r11 = 'format' - r12 = [r2, r9, r10] - r13 = load_address r12 - r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0) - if is_error(r14) goto L9 (error at __repr__:74) else goto L4 + return r7 L4: - dec_ref r9 - r15 = cast(str, r14) - if is_error(r15) goto L8 (error at __repr__:74) else goto L5 -L5: - r16 = ')' - r17 = PyList_New(3) - if is_error(r17) goto L10 (error at __repr__:74) else goto L6 -L6: - r18 = get_element_ptr r17 ob_item :: PyListObject - r19 = load_mem r18 :: ptr* - inc_ref r1 - set_mem r19, r1 :: builtins.object* - r20 = r19 + 8 - set_mem r20, r15 :: builtins.object* - inc_ref r16 - r21 = r19 + 16 - set_mem r21, r16 :: builtins.object* - r22 = PyUnicode_Join(r0, r17) - dec_ref r17 - if is_error(r22) goto L8 (error at __repr__:74) else goto L7 -L7: - return r22 -L8: - r23 = :: str - return r23 -L9: - dec_ref r9 - goto L8 -L10: - dec_ref r15 - goto L8 + r8 = :: str + return r8 def to_0x_hex_HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object @@ -1852,801 +1235,628 @@ L3: 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 __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__:49) 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__:50) 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__:50) else goto L5 -L5: - dec_ref r0 - r6 = cast(faster_hexbytes.main.HexBytes, r5) - if is_error(r6) goto L7 (error at __new__:50) 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__:63) else goto L1 -L1: - r5 = cast(union[int, bytes], r4) - if is_error(r5) goto L14 (error at __getitem__:63) 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__:65) else goto L4 -L4: - r8 = box(int, r7) - return r8 + 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: - r9 = CPy_TYPE(self) - r10 = faster_hexbytes.main.HexBytes :: type - r11 = r9 == r10 - if r11 goto L15 else goto L10 :: bool + 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: - r12 = cast(bytes, r5) - if is_error(r12) goto L14 (error at __getitem__:69) else goto L7 + 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: - 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__:69) else goto L8 + 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: - dec_ref r12 - r17 = cast(faster_hexbytes.main.HexBytes, r16) - if is_error(r17) goto L14 (error at __getitem__:69) else goto L9 + 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: - return r17 + r29 = cast(str, r28) + if is_error(r29) goto L12 (error at :11) else goto L10 L10: - r18 = cast(bytes, r5) - if is_error(r18) goto L17 (error at __getitem__:70) else goto L11 + 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: - 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__:70) else goto L12 + return 1 L12: - dec_ref r18 - r22 = cast(faster_hexbytes.main.HexBytes, r21) - if is_error(r22) goto L14 (error at __getitem__:70) 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__:73) else goto L1 -L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at __repr__:73) else goto L2 -L2: - r6 = "')" - r7 = CPyStr_Build(3, r0, r5, r6) - dec_ref r5 - if is_error(r7) goto L4 (error at __repr__:73) 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:79) else goto L1 -L1: - r5 = cast(str, r4) - if is_error(r5) goto L4 (error at to_0x_hex:79) else goto L2 -L2: - r6 = CPyStr_Build(2, r0, r5) - dec_ref r5 - if is_error(r6) goto L4 (error at to_0x_hex:79) 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 + r34 = :: None + return r34 -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 +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 :: bytes - r8 :: tuple[object, bytes] - r9, r10 :: tuple[object, tuple[object, bytes]] + 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 = faster_hexbytes.main._bytes_new :: static - if is_error(r0) goto L1 else goto L3 + r0 = PyBytes_Check(val) + if r0 goto L1 else goto L3 :: bool L1: - r1 = raise NameError('value for final name "_bytes_new" was not set') - if not r1 goto L6 (error at __reduce__:89) else goto L2 :: bool + inc_ref val + r1 = cast(bytes, val) + if is_error(r1) goto L51 (error at to_bytes:19) else goto L2 L2: - unreachable + return r1 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__:89) else goto L4 + r2 = PyUnicode_Check(val) + if r2 goto L4 else goto L7 :: bool L4: - r7 = cast(bytes, r6) - if is_error(r7) goto L7 (error at __reduce__:89) else goto L5 + inc_ref val + r3 = cast(str, val) + if is_error(r3) goto L51 (error at to_bytes:21) else goto L5 L5: - r8 = (r2, r7) - inc_ref r0 - r9 = (r0, r8) - return r9 + r4 = hexstr_to_bytes(r3) + dec_ref r3 + if is_error(r4) goto L51 (error at to_bytes:21) else goto L6 L6: - r10 = :: tuple[object, tuple[object, bytes]] - return r10 + return r4 L7: - dec_ref r2 - goto L6 + 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 __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 +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 :: dict - r26, r27 :: object - r28 :: str - r29 :: dict + r25 :: object + r26 :: object[1] + r27 :: object_ptr + r28 :: object + r29 :: bit 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 :: object - r121 :: object[1] - r122 :: object_ptr - r123, r124 :: object - r125 :: object[1] - r126 :: object_ptr - r127 :: object - r128 :: dict - r129 :: str - r130 :: i32 - r131 :: bit - r132 :: object - r133 :: None + r31 :: bool + r32 :: object[1] + r33 :: object_ptr + r34 :: object + r35, r36 :: bytes L0: - r0 = builtins :: module - r1 = load_address _Py_NoneStruct - r2 = r0 != r1 - if r2 goto L3 else goto L1 :: bool + 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: - r3 = 'builtins' - r4 = PyImport_Import(r3) - if is_error(r4) goto L48 (error at :-1) else goto L2 + if r4 goto L2 else goto L5 :: bool L2: - builtins = r4 :: module - dec_ref r4 + r5 = CPyStr_GetSlice(hexstr, 4, 9223372036854775806) + if is_error(r5) goto L31 (error at hexstr_to_bytes:41) else goto L3 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 L48 (error at :1) else goto L4 + r6 = cast(str, r5) + if is_error(r6) goto L31 (error at hexstr_to_bytes:41) 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 L48 else goto L5 :: bool + non_prefixed_hex = r6 + goto L6 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 L48 (error at :15) else goto L6 + inc_ref hexstr + non_prefixed_hex = hexstr 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 L48 (error at :18) else goto L7 + 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: - 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 L48 (error at :22) else goto L8 + r9 = r7 << 1 + r10 = CPyTagged_Remainder(r9, 4) + if is_error(r10) goto L32 (error at hexstr_to_bytes:46) else goto L8 L8: - faster_hexbytes._utils = r30 :: module - dec_ref r30 - if 0 goto L9 else goto L9 :: bool + r11 = r10 != 0 + dec_ref r10 :: int + if r11 goto L9 else goto L11 :: bool L9: - r31 = faster_hexbytes.main.globals :: static - r32 = 'Union' - r33 = CPyDict_GetItem(r31, r32) - if is_error(r33) goto L48 (error at :31) else goto L10 + 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: - 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 L49 (error at :31) else goto L11 + padded_hex = r13 + goto L12 L11: - r40 = load_address PyLong_Type - r41 = builtins :: module - r42 = 'memoryview' - r43 = CPyObject_GetAttr(r41, r42) - if is_error(r43) goto L50 (error at :31) else goto L12 + padded_hex = non_prefixed_hex 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 L48 (error at :31) else goto L13 + r14 = PyUnicode_AsASCIIString(padded_hex) + if is_error(r14) goto L14 (error at hexstr_to_bytes:52) else goto L33 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 L48 (error at :31) else goto L14 :: bool + goto L25 L14: - r51 = load_address PyBytes_Type - r52 = '__new__' - r53 = CPyObject_GetAttr(r51, r52) - if is_error(r53) goto L48 (error at :33) else goto L15 + 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: - 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 L48 (error at :33) else goto L16 :: bool + r19 = CPy_ExceptionMatches(r18) + dec_ref r18 + if r19 goto L16 else goto L35 :: bool L16: - r58 = hexbytes.main :: module - r59 = 'HexBytes' - r60 = CPyObject_GetAttr(r58, r59) - if is_error(r60) goto L48 (error at :37) else goto L17 + 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: - r61 = PyTuple_Pack(1, r60) - dec_ref r60 - if is_error(r61) goto L48 (error at :37) else goto L18 + 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: - r62 = load_address PyType_Type - r63 = CPy_CalculateMetaclass(r62, r61) - if is_error(r63) goto L51 (error at :37) else goto L19 + 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: - r64 = '__prepare__' - r65 = PyObject_HasAttr(r63, r64) - if r65 goto L20 else goto L24 :: bool + 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: - r66 = 'HexBytes' - r67 = '__prepare__' - r68 = CPyObject_GetAttr(r63, r67) - if is_error(r68) goto L51 (error at :37) else goto L21 + unreachable L21: - r69 = [r66, r61] - r70 = load_address r69 - r71 = PyObject_Vectorcall(r68, r70, 2, 0) - dec_ref r68 - if is_error(r71) goto L51 (error at :37) else goto L22 + CPy_Reraise() + if not 0 goto L23 else goto L38 :: bool L22: - r72 = cast(dict, r71) - if is_error(r72) goto L51 (error at :37) else goto L23 + unreachable L23: - r73 = r72 - goto L26 + CPy_RestoreExcInfo(r15) + dec_ref r15 + r29 = CPy_KeepPropagating() + if not r29 goto L31 else goto L24 :: bool L24: - r74 = PyDict_New() - if is_error(r74) goto L51 (error at :37) else goto L25 + unreachable L25: - r73 = r74 + r30 = faster_hexbytes._utils.unhexlify :: static + if is_error(r30) goto L39 else goto L28 L26: - r75 = PyDict_New() - if is_error(r75) goto L52 (error at :37) else goto L27 + 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: - r76 = __new___HexBytes_obj() - if is_error(r76) goto L53 (error at :48) else goto L28 + unreachable L28: - r77 = builtins :: module - r78 = 'staticmethod' - r79 = CPyObject_GetAttr(r77, r78) - if is_error(r79) goto L54 (error at :48) else goto L29 + 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: - r80 = [r76] - r81 = load_address r80 - r82 = PyObject_Vectorcall(r79, r81, 1, 0) - dec_ref r79 - if is_error(r82) goto L54 (error at :48) else goto L30 + dec_ref r14 + r35 = cast(bytes, r34) + if is_error(r35) goto L31 (error at hexstr_to_bytes:58) 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 L53 (error at :48) else goto L31 :: bool + return r35 L31: - r86 = __getitem___HexBytes_obj() - if is_error(r86) goto L53 (error at :60) else goto L32 + r36 = :: bytes + return r36 L32: - r87 = '__getitem__' - r88 = CPyDict_SetItem(r73, r87, r86) - dec_ref r86 - r89 = r88 >= 0 :: signed - if not r89 goto L53 (error at :60) else goto L33 :: bool + dec_ref non_prefixed_hex + goto L31 L33: - r90 = __repr___HexBytes_obj() - if is_error(r90) goto L53 (error at :72) else goto L34 + dec_ref padded_hex + goto L13 L34: - r91 = '__repr__' - r92 = CPyDict_SetItem(r73, r91, r90) - dec_ref r90 - r93 = r92 >= 0 :: signed - if not r93 goto L53 (error at :72) else goto L35 :: bool + dec_ref padded_hex + goto L23 L35: - r94 = to_0x_hex_HexBytes_obj() - if is_error(r94) goto L53 (error at :75) else goto L36 + dec_ref padded_hex + goto L21 L36: - r95 = 'to_0x_hex' - r96 = CPyDict_SetItem(r73, r95, r94) - dec_ref r94 - r97 = r96 >= 0 :: signed - if not r97 goto L53 (error at :75) else goto L37 :: bool + dec_ref r22 + goto L23 L37: - r98 = __reduce___HexBytes_obj() - if is_error(r98) goto L53 (error at :81) else goto L38 + dec_ref r15 + goto L20 L38: - r99 = '__reduce__' - r100 = CPyDict_SetItem(r73, r99, r98) - dec_ref r98 - r101 = r100 >= 0 :: signed - if not r101 goto L53 (error at :81) else goto L39 :: bool + dec_ref r15 + goto L22 L39: - r102 = 'HexBytes' - r103 = '__annotations__' - r104 = CPyDict_SetItem(r73, r103, r75) - dec_ref r75 - r105 = r104 >= 0 :: signed - if not r105 goto L52 (error at :37) else goto L40 :: bool + dec_ref r14 + goto L26 L40: - r106 = 'mypyc filler docstring' - r107 = '__doc__' - r108 = CPyDict_SetItem(r73, r107, r106) - r109 = r108 >= 0 :: signed - if not r109 goto L52 (error at :37) 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 L52 (error at :37) 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 L52 (error at :37) 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 L55 (error at :36) else goto L44 -L44: - r120 = box(bool, 0) - r121 = [r120] - r122 = load_address r121 - r123 = ('native_class',) - r124 = PyObject_Vectorcall(r119, r122, 0, r123) - dec_ref r119 - if is_error(r124) goto L55 (error at :36) else goto L45 -L45: - r125 = [r116] - r126 = load_address r125 - r127 = PyObject_Vectorcall(r124, r126, 1, 0) - dec_ref r124 - if is_error(r127) goto L55 (error at :37) else goto L46 -L46: - dec_ref r116 - faster_hexbytes.main.HexBytes = r127 :: type - r128 = faster_hexbytes.main.globals :: static - r129 = 'HexBytes' - r130 = PyDict_SetItem(r128, r129, r127) - dec_ref r127 - r131 = r130 >= 0 :: signed - if not r131 goto L48 (error at :37) else goto L47 :: bool -L47: - r132 = faster_hexbytes.main.HexBytes :: type + 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 -L48: - r133 = :: None - return r133 -L49: - dec_ref r33 - goto L48 -L50: - dec_ref r33 - dec_ref r39 - goto L48 -L51: - dec_ref r61 - goto L48 -L52: - dec_ref r61 - dec_ref r73 - goto L48 -L53: - dec_ref r61 - dec_ref r73 - dec_ref r75 - goto L48 -L54: - dec_ref r61 - dec_ref r73 - dec_ref r75 - dec_ref r76 - goto L48 -L55: - dec_ref r116 - goto L48 +L8: + r26 = :: None + return r26 From e4d966ffaccf469c540b5a2cda6ebe54adf9130b Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 15:49:51 -0400 Subject: [PATCH 59/70] fix(cicd): missing dep in release workflow --- .github/workflows/release.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml index 3608a5b..802fbf8 100644 --- a/.github/workflows/release.yaml +++ b/.github/workflows/release.yaml @@ -129,7 +129,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install setuptools wheel twine + pip install setuptools wheel twine mypy==1.18.2 - name: Build sdist run: | From 04c6a8e3da54f19ea72234afeac245b67d60c4e9 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 30 Sep 2025 16:03:04 -0400 Subject: [PATCH 60/70] fix(cicd): missing dep in release workflow --- .github/workflows/release.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml index 802fbf8..4cb1a77 100644 --- a/.github/workflows/release.yaml +++ b/.github/workflows/release.yaml @@ -129,7 +129,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install setuptools wheel twine mypy==1.18.2 + pip install setuptools wheel twine mypy==1.18.2 hexbytes==1.3.1 - name: Build sdist run: | From aa1b04cf6d3cc90e1d1564f7028325a01048c949 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 30 Sep 2025 20:03:29 +0000 Subject: [PATCH 61/70] chore: compile C files for source control --- build/ops.txt | 206 +++++++++++++++++++++++++------------------------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 8dfadfc..50ef3d3 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1184,109 +1184,6 @@ 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 @@ -1860,3 +1757,106 @@ L7: L8: r26 = :: None return r26 + +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 From ac67e298a5cc1be8dae3c08fdbfea9eff10752ce Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Wed, 1 Oct 2025 00:57:01 -0400 Subject: [PATCH 62/70] Update README.md --- README.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/README.md b/README.md index c7e0ade..7440cb6 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 eth-abi 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) From 092cedefb6a7f641cefbf404d47538ce493542ee Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 1 Oct 2025 04:57:27 +0000 Subject: [PATCH 63/70] chore: compile C files for source control --- build/ops.txt | 206 +++++++++++++++++++++++++------------------------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 50ef3d3..7a59370 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,3 +1,106 @@ +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 __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit @@ -1757,106 +1860,3 @@ L7: L8: r26 = :: None return r26 - -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 From 72fb548a39d091f2c6b9aa9e94abee8b3917969b Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Wed, 1 Oct 2025 00:57:46 -0400 Subject: [PATCH 64/70] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7440cb6..d9c368e 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ ##### 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 eth-abi readme is below: +##### The original hexbytes readme is below: # HexBytes From 554bb2ae943e78899cbf2e0c55465f3e9aae0963 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 1 Oct 2025 04:58:33 +0000 Subject: [PATCH 65/70] chore: compile C files for source control --- build/ops.txt | 206 +++++++++++++++++++++++++------------------------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 7a59370..50ef3d3 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,106 +1,3 @@ -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 __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit @@ -1860,3 +1757,106 @@ L7: L8: r26 = :: None return r26 + +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 From a7d1cc1d1fceeb1b0260759cdeded73d32b4c7bd Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Sat, 4 Oct 2025 23:21:18 -0400 Subject: [PATCH 66/70] chore(cicd): limit tox action concurrency --- .github/workflows/tox.yaml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 36b0e10..e145fb1 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -8,6 +8,10 @@ on: 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 }}) From b0df50655708d2ca133bc469e184d1e8a3fdf67b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 5 Oct 2025 03:21:45 +0000 Subject: [PATCH 67/70] chore: compile C files for source control --- build/ops.txt | 206 +++++++++++++++++++++++++------------------------- 1 file changed, 103 insertions(+), 103 deletions(-) diff --git a/build/ops.txt b/build/ops.txt index 50ef3d3..7a59370 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,3 +1,106 @@ +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 __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit @@ -1757,106 +1860,3 @@ L7: L8: r26 = :: None return r26 - -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 From 9dc06e7e6a4e17c7de51e0ae655c39e5da579999 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 7 Oct 2025 03:39:15 -0400 Subject: [PATCH 68/70] feat(cicd): normalize C files for diffchecking (#12) * feat(cicd): normalize C files for diffchecking * chore: compile C files for source control --------- Co-authored-by: github-actions[bot] --- .github/workflows/compile.yaml | 20 + build/__native_6a32f4913d613d6a7ddf.c | 557 +++++++++++++------------- build/faster_hexbytes.c | 3 + build/ops.txt | 206 +++++----- 4 files changed, 406 insertions(+), 380 deletions(-) diff --git a/.github/workflows/compile.yaml b/.github/workflows/compile.yaml index 71baa09..7f0ffcd 100644 --- a/.github/workflows/compile.yaml +++ b/.github/workflows/compile.yaml @@ -4,9 +4,15 @@ 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 }} @@ -31,6 +37,20 @@ jobs: 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: | diff --git a/build/__native_6a32f4913d613d6a7ddf.c b/build/__native_6a32f4913d613d6a7ddf.c index 5effd18..c73096d 100644 --- a/build/__native_6a32f4913d613d6a7ddf.c +++ b/build/__native_6a32f4913d613d6a7ddf.c @@ -1,3 +1,6 @@ +#ifndef DIFFCHECK_PLACEHOLDER +#define DIFFCHECK_PLACEHOLDER 0 +#endif #include "init.c" #include "getargs.c" #include "getargsfast.c" @@ -102,7 +105,7 @@ char CPyDef_faster_hexbytes_____top_level__(void) { 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[3]; /* 'builtins' */ + 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); @@ -112,33 +115,33 @@ char CPyDef_faster_hexbytes_____top_level__(void) { CPy_INCREF(CPyModule_builtins); CPy_DECREF(cpy_r_r4); CPyL3: ; - cpy_r_r5 = CPyStatics[73]; /* ('version',) */ - cpy_r_r6 = CPyStatics[74]; /* ('__version',) */ - cpy_r_r7 = CPyStatics[6]; /* 'importlib.metadata' */ + 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", "", 1, CPyStatic_faster_hexbytes___globals); + 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[75]; /* ('HexBytes',) */ - cpy_r_r11 = CPyStatics[8]; /* 'faster_hexbytes.main' */ + 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", "", 5, CPyStatic_faster_hexbytes___globals); + 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[7]; /* 'HexBytes' */ + 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", "", 9, CPyStatic_faster_hexbytes___globals); + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); goto CPyL12; } cpy_r_r16 = (CPyPtr)&((PyListObject *)cpy_r_r15)->ob_item; @@ -146,20 +149,20 @@ CPyL3: ; CPy_INCREF(cpy_r_r14); *(PyObject * *)cpy_r_r17 = cpy_r_r14; cpy_r_r18 = CPyStatic_faster_hexbytes___globals; - cpy_r_r19 = CPyStatics[9]; /* '__all__' */ + 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", "", 9, CPyStatic_faster_hexbytes___globals); + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); goto CPyL12; } - cpy_r_r22 = CPyStatics[10]; /* 'hexbytes' */ + cpy_r_r22 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'hexbytes' */ cpy_r_r23 = CPyStatic_faster_hexbytes___globals; - cpy_r_r24 = CPyStatics[5]; /* '__version' */ + 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", "", 11, CPyStatic_faster_hexbytes___globals); + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); goto CPyL12; } PyObject *cpy_r_r26[1] = {cpy_r_r22}; @@ -167,7 +170,7 @@ CPyL3: ; 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", "", 11, CPyStatic_faster_hexbytes___globals); + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); goto CPyL12; } if (likely(PyUnicode_Check(cpy_r_r28))) @@ -177,12 +180,12 @@ CPyL3: ; goto CPyL12; } cpy_r_r30 = CPyStatic_faster_hexbytes___globals; - cpy_r_r31 = CPyStatics[11]; /* '__version__' */ + 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", "", 11, CPyStatic_faster_hexbytes___globals); + CPy_AddTraceback("faster_hexbytes/__init__.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_hexbytes___globals); goto CPyL12; } return 1; @@ -348,7 +351,7 @@ CPyL3: ; 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", 21, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } return cpy_r_r4; @@ -360,7 +363,7 @@ CPyL7: ; 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", 23, CPyStatic__utils___globals); + 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))) @@ -378,16 +381,16 @@ CPyL11: ; } else cpy_r_r12 = cpy_r_val == Py_True; if (unlikely(cpy_r_r12 == 2)) { - CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 25, CPyStatic__utils___globals); + 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[71]; /* b'\x01' */ + 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[72]; /* b'\x00' */ + cpy_r_r15 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* b'\x00' */ CPy_INCREF(cpy_r_r15); cpy_r_r14 = cpy_r_r15; CPyL16: ; @@ -401,7 +404,7 @@ CPyL17: ; 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", 29, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } cpy_r_r18 = cpy_r_r17 & 1; @@ -420,34 +423,34 @@ CPyL22: ; CPyL23: ; CPyTagged_DECREF(cpy_r_r17); if (!cpy_r_r23) goto CPyL31; - cpy_r_r25 = CPyStatics[12]; /* 'Cannot convert negative integer ' */ + 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", 30, CPyStatic__utils___globals); + 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", 30, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } - cpy_r_r28 = CPyStatics[13]; /* ' to bytes' */ + 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", 30, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } cpy_r_r30 = CPyModule_builtins; - cpy_r_r31 = CPyStatics[14]; /* 'ValueError' */ + 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", 30, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL52; } PyObject *cpy_r_r33[1] = {cpy_r_r29}; @@ -455,14 +458,14 @@ CPyL23: ; 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", 30, CPyStatic__utils___globals); + 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", 30, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } CPy_Unreachable(); @@ -473,14 +476,14 @@ CPyL31: ; 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", 32, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } cpy_r_r37 = CPyModule_builtins; - cpy_r_r38 = CPyStatics[15]; /* 'hex' */ + 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", 32, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL53; } cpy_r_r40 = CPyTagged_StealAsObject(cpy_r_r36); @@ -489,7 +492,7 @@ CPyL31: ; 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", 32, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL54; } CPy_DECREF(cpy_r_r40); @@ -502,23 +505,23 @@ CPyL31: ; 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", 32, CPyStatic__utils___globals); + 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[16]; /* 'memoryview' */ + 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", 33, CPyStatic__utils___globals); + 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", 33, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } cpy_r_r51 = cpy_r_r49; @@ -528,7 +531,7 @@ CPyL37: ; 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", 34, CPyStatic__utils___globals); + 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))) @@ -539,35 +542,35 @@ CPyL37: ; } return cpy_r_r56; CPyL43: ; - cpy_r_r57 = CPyStatics[17]; /* '' */ - cpy_r_r58 = CPyStatics[18]; /* 'Cannot convert ' */ - cpy_r_r59 = CPyStatics[19]; /* '{!r:{}}' */ - cpy_r_r60 = CPyStatics[17]; /* '' */ - cpy_r_r61 = CPyStatics[20]; /* 'format' */ + 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", 36, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } - cpy_r_r65 = CPyStatics[21]; /* ' of type ' */ - cpy_r_r66 = CPyStatics[22]; /* '{:{}}' */ + 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[17]; /* '' */ - cpy_r_r69 = CPyStatics[20]; /* 'format' */ + 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", 36, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL55; } CPy_DECREF(cpy_r_r67); - cpy_r_r73 = CPyStatics[13]; /* ' to bytes' */ + 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", 36, CPyStatic__utils___globals); + 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; @@ -587,14 +590,14 @@ CPyL43: ; 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", 36, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } cpy_r_r82 = CPyModule_builtins; - cpy_r_r83 = CPyStatics[23]; /* 'TypeError' */ + 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", 36, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL57; } PyObject *cpy_r_r85[1] = {cpy_r_r81}; @@ -602,14 +605,14 @@ CPyL43: ; 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", 36, CPyStatic__utils___globals); + 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", 36, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL51; } CPy_Unreachable(); @@ -678,7 +681,7 @@ __LL1: ; PyObject *retval = CPyDef__utils___to_bytes(arg_val); return retval; fail: ; - CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", 11, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); return NULL; } @@ -720,8 +723,8 @@ PyObject *CPyDef__utils___hexstr_to_bytes(PyObject *cpy_r_hexstr) { PyObject *cpy_r_r34; PyObject *cpy_r_r35; PyObject *cpy_r_r36; - cpy_r_r0 = CPyStatics[24]; /* '0x' */ - cpy_r_r1 = CPyStatics[25]; /* '0X' */ + 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; @@ -736,13 +739,13 @@ PyObject *CPyDef__utils___hexstr_to_bytes(PyObject *cpy_r_hexstr) { 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", 40, CPyStatic__utils___globals); + 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", 41, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL31; } if (likely(PyUnicode_Check(cpy_r_r5))) @@ -760,23 +763,23 @@ 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", 46, CPyStatic__utils___globals); + 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", 46, CPyStatic__utils___globals); + 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[26]; /* '0' */ + 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", 47, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL31; } cpy_r_padded_hex = cpy_r_r13; @@ -786,7 +789,7 @@ CPyL11: ; 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", 52, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL14; } else goto CPyL33; @@ -795,28 +798,28 @@ CPyL13: ; CPyL14: ; cpy_r_r15 = CPy_CatchError(); cpy_r_r16 = CPyModule_builtins; - cpy_r_r17 = CPyStatics[27]; /* 'UnicodeDecodeError' */ + 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", 53, CPyStatic__utils___globals); + 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[28]; /* 'hex string ' */ - cpy_r_r21 = CPyStatics[29]; /* ' may only contain [0-9a-fA-F] characters' */ + 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", 55, CPyStatic__utils___globals); + 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[14]; /* 'ValueError' */ + 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", 54, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL36; } PyObject *cpy_r_r26[1] = {cpy_r_r22}; @@ -824,14 +827,14 @@ CPyL14: ; 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", 54, CPyStatic__utils___globals); + 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", 54, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL23; } else goto CPyL37; @@ -863,7 +866,7 @@ 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", 58, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL31; } CPy_Unreachable(); @@ -872,7 +875,7 @@ CPyL28: ; 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", 58, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL40; } CPy_DECREF(cpy_r_r14); @@ -936,7 +939,7 @@ PyObject *CPyPy__utils___hexstr_to_bytes(PyObject *self, PyObject *const *args, PyObject *retval = CPyDef__utils___hexstr_to_bytes(arg_hexstr); return retval; fail: ; - CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", 39, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "hexstr_to_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); return NULL; } @@ -970,7 +973,7 @@ char CPyDef__utils_____top_level__(void) { 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[3]; /* 'builtins' */ + 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); @@ -985,39 +988,39 @@ CPyL3: ; 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[77]; /* (('binascii', 'binascii', 'binascii'),) */ + cpy_r_r10 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* (('binascii', 'binascii', 'binascii'),) */ cpy_r_r11 = CPyStatic__utils___globals; - cpy_r_r12 = CPyStatics[31]; /* 'faster_hexbytes/_utils.py' */ - cpy_r_r13 = CPyStatics[32]; /* '' */ + 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[78]; /* ('Final', 'Union') */ - cpy_r_r16 = CPyStatics[35]; /* 'typing' */ + 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", "", 2, CPyStatic__utils___globals); + 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[36]; /* 'unhexlify' */ + 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", "", 8, CPyStatic__utils___globals); + 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[36]; /* 'unhexlify' */ + 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", "", 8, CPyStatic__utils___globals); + CPy_AddTraceback("faster_hexbytes/_utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic__utils___globals); goto CPyL8; } return 1; @@ -1722,7 +1725,7 @@ PyObject *CPyDef_main_____new___3_HexBytes_obj_____call__(PyObject *cpy_r___mypy 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__", 50, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL7; } cpy_r_r1 = CPyStatic_main____bytes_new; @@ -1734,7 +1737,7 @@ 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__", 51, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL7; } CPy_Unreachable(); @@ -1743,7 +1746,7 @@ CPyL4: ; 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__", 51, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL9; } CPy_DECREF(cpy_r_r0); @@ -1809,7 +1812,7 @@ __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__", 49, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__new__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); return NULL; } @@ -1874,12 +1877,12 @@ PyObject *CPyDef_main_____getitem___3_HexBytes_obj_____call__(PyObject *cpy_r___ PyObject *cpy_r_r22; PyObject *cpy_r_r23; cpy_r_r0 = (PyObject *)&PyBytes_Type; - cpy_r_r1 = CPyStatics[37]; /* '__getitem__' */ + 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__", 64, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL14; } if (PyLong_Check(cpy_r_r4)) @@ -1906,7 +1909,7 @@ __LL5: ; } CPy_DECREF(cpy_r_r5); if (unlikely(cpy_r_r7 == CPY_INT_TAG)) { - CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", 66, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL14; } cpy_r_r8 = CPyTagged_StealAsObject(cpy_r_r7); @@ -1931,7 +1934,7 @@ CPyL6: ; 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__", 70, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL16; } CPy_DECREF(cpy_r_r12); @@ -1954,7 +1957,7 @@ CPyL10: ; 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__", 71, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL18; } CPy_DECREF(cpy_r_r18); @@ -2003,7 +2006,7 @@ PyObject *CPyPy_main_____getitem___3_HexBytes_obj_____call__(PyObject *self, PyO 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__", 61, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__getitem__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); return NULL; } @@ -2054,13 +2057,13 @@ PyObject *CPyDef_main_____repr___3_HexBytes_obj_____call__(PyObject *cpy_r___myp PyObject *cpy_r_r6; PyObject *cpy_r_r7; PyObject *cpy_r_r8; - cpy_r_r0 = CPyStatics[38]; /* "HexBytes('0x" */ - cpy_r_r1 = CPyStatics[15]; /* 'hex' */ + 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__", 74, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL4; } if (likely(PyUnicode_Check(cpy_r_r4))) @@ -2069,11 +2072,11 @@ PyObject *CPyDef_main_____repr___3_HexBytes_obj_____call__(PyObject *cpy_r___myp CPy_TypeErrorTraceback("faster_hexbytes/main.py", "__repr__", 74, CPyStatic_main___globals, "str", cpy_r_r4); goto CPyL4; } - cpy_r_r6 = CPyStatics[39]; /* "')" */ + 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__", 74, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL4; } return cpy_r_r7; @@ -2101,7 +2104,7 @@ PyObject *CPyPy_main_____repr___3_HexBytes_obj_____call__(PyObject *self, PyObje PyObject *retval = CPyDef_main_____repr___3_HexBytes_obj_____call__(arg___mypyc_self__, arg_self); return retval; fail: ; - CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", 73, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__repr__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); return NULL; } @@ -2151,13 +2154,13 @@ PyObject *CPyDef_main___to_0x_hex_HexBytes_obj_____call__(PyObject *cpy_r___mypy PyObject *cpy_r_r5; PyObject *cpy_r_r6; PyObject *cpy_r_r7; - cpy_r_r0 = CPyStatics[24]; /* '0x' */ - cpy_r_r1 = CPyStatics[15]; /* 'hex' */ + 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", 80, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "to_0x_hex", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL4; } if (likely(PyUnicode_Check(cpy_r_r4))) @@ -2169,7 +2172,7 @@ PyObject *CPyDef_main___to_0x_hex_HexBytes_obj_____call__(PyObject *cpy_r___mypy 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", 80, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "to_0x_hex", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL4; } return cpy_r_r6; @@ -2197,7 +2200,7 @@ PyObject *CPyPy_main___to_0x_hex_HexBytes_obj_____call__(PyObject *self, PyObjec 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", 76, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "to_0x_hex", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); return NULL; } @@ -2255,7 +2258,7 @@ tuple_T2OT2OO CPyDef_main_____reduce___3_HexBytes_obj_____call__(PyObject *cpy_r 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__", 90, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL6; } CPy_Unreachable(); @@ -2266,7 +2269,7 @@ CPyL3: ; 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__", 90, CPyStatic_main___globals); + 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))) @@ -2325,7 +2328,7 @@ PyObject *CPyPy_main_____reduce___3_HexBytes_obj_____call__(PyObject *self, PyOb PyTuple_SET_ITEM(retbox, 1, __tmp8); return retbox; fail: ; - CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", 82, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "__reduce__", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); return NULL; } @@ -2597,7 +2600,7 @@ char CPyDef_main_____top_level__(void) { 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[3]; /* 'builtins' */ + 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); @@ -2607,13 +2610,13 @@ char CPyDef_main_____top_level__(void) { CPy_INCREF(CPyModule_builtins); CPy_DECREF(cpy_r_r4); CPyL3: ; - cpy_r_r5 = CPyStatics[79]; /* ('TYPE_CHECKING', 'Callable', 'Final', 'Tuple', 'Type', + cpy_r_r5 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('TYPE_CHECKING', 'Callable', 'Final', 'Tuple', 'Type', 'Union', 'overload') */ - cpy_r_r6 = CPyStatics[35]; /* 'typing' */ + 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", "", 1, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL105; } CPyModule_typing = cpy_r_r8; @@ -2624,68 +2627,68 @@ CPyL3: ; 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[81]; /* (('hexbytes.main', 'hexbytes.main', 'hexbytes'),) */ + cpy_r_r14 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* (('hexbytes.main', 'hexbytes.main', 'hexbytes'),) */ cpy_r_r15 = CPyStatic_main___globals; - cpy_r_r16 = CPyStatics[46]; /* 'faster_hexbytes/main.py' */ - cpy_r_r17 = CPyStatics[32]; /* '' */ + 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[82]; /* ('mypyc_attr',) */ - cpy_r_r20 = CPyStatics[48]; /* 'mypy_extensions' */ + 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", "", 15, CPyStatic_main___globals); + 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[83]; /* ('Self',) */ - cpy_r_r24 = CPyStatics[50]; /* 'typing_extensions' */ + 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", "", 18, CPyStatic_main___globals); + 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[84]; /* ('to_bytes',) */ - cpy_r_r28 = CPyStatics[52]; /* 'faster_hexbytes._utils' */ + 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", "", 22, CPyStatic_main___globals); + 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[34]; /* 'Union' */ + 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", "", 32, CPyStatic_main___globals); + 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[53]; /* 'bytearray' */ + 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", "", 32, CPyStatic_main___globals); + 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[16]; /* 'memoryview' */ + 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", "", 32, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL107; } CPy_INCREF(cpy_r_r34); @@ -2717,63 +2720,63 @@ CPyL3: ; CPy_DECREF(cpy_r_r33); CPy_DECREF(cpy_r_r45); if (unlikely(cpy_r_r46 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 32, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL105; } cpy_r_r47 = CPyStatic_main___globals; - cpy_r_r48 = CPyStatics[54]; /* 'BytesLike' */ + 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", "", 32, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL105; } cpy_r_r51 = (PyObject *)&PyBytes_Type; - cpy_r_r52 = CPyStatics[55]; /* '__new__' */ + 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", "", 34, CPyStatic_main___globals); + 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[56]; /* '_bytes_new' */ + 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", "", 34, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL105; } cpy_r_r58 = CPyModule_hexbytes___main; - cpy_r_r59 = CPyStatics[7]; /* 'HexBytes' */ + 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", "", 38, CPyStatic_main___globals); + 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", "", 38, CPyStatic_main___globals); + 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", "", 38, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL108; } - cpy_r_r64 = CPyStatics[57]; /* '__prepare__' */ + 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[7]; /* 'HexBytes' */ - cpy_r_r67 = CPyStatics[57]; /* '__prepare__' */ + 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", "", 38, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL108; } PyObject *cpy_r_r69[2] = {cpy_r_r66, cpy_r_r61}; @@ -2781,7 +2784,7 @@ CPyL3: ; 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", "", 38, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL108; } if (likely(PyDict_Check(cpy_r_r71))) @@ -2795,26 +2798,26 @@ CPyL3: ; CPyL24: ; cpy_r_r74 = PyDict_New(); if (unlikely(cpy_r_r74 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 38, CPyStatic_main___globals); + 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", "", 38, CPyStatic_main___globals); + 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", "", 49, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL110; } cpy_r_r77 = CPyModule_builtins; - cpy_r_r78 = CPyStatics[58]; /* 'staticmethod' */ + 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", "", 49, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL111; } PyObject *cpy_r_r80[1] = {cpy_r_r76}; @@ -2822,120 +2825,120 @@ CPyL26: ; 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", "", 49, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL111; } CPy_DECREF_NO_IMM(cpy_r_r76); - cpy_r_r83 = CPyStatics[55]; /* '__new__' */ + 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", "", 49, CPyStatic_main___globals); + 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", "", 61, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL110; } - cpy_r_r87 = CPyStatics[37]; /* '__getitem__' */ + 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", "", 61, CPyStatic_main___globals); + 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", "", 73, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL110; } - cpy_r_r91 = CPyStatics[59]; /* '__repr__' */ + 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", "", 73, CPyStatic_main___globals); + 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", "", 76, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL110; } - cpy_r_r95 = CPyStatics[60]; /* 'to_0x_hex' */ + 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", "", 76, CPyStatic_main___globals); + 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", "", 82, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL110; } - cpy_r_r99 = CPyStatics[61]; /* '__reduce__' */ + 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", "", 82, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL110; } - cpy_r_r102 = CPyStatics[7]; /* 'HexBytes' */ - cpy_r_r103 = CPyStatics[62]; /* '__annotations__' */ + 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", "", 38, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL109; } - cpy_r_r106 = CPyStatics[63]; /* 'mypyc filler docstring' */ - cpy_r_r107 = CPyStatics[64]; /* '__doc__' */ + 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", "", 38, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL109; } - cpy_r_r110 = CPyStatics[8]; /* 'faster_hexbytes.main' */ - cpy_r_r111 = CPyStatics[65]; /* '__module__' */ + 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", "", 38, CPyStatic_main___globals); + 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", "", 38, CPyStatic_main___globals); + 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[47]; /* 'mypyc_attr' */ + 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", "", 37, CPyStatic_main___globals); + 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[85]; /* ('native_class', 'allow_interpreted_subclasses') */ + 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", "", 37, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL112; } PyObject *cpy_r_r126[1] = {cpy_r_r116}; @@ -2943,49 +2946,49 @@ CPyL26: ; 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", "", 38, CPyStatic_main___globals); + 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[7]; /* 'HexBytes' */ + 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", "", 38, CPyStatic_main___globals); + 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[7]; /* 'HexBytes' */ + 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", "", 97, CPyStatic_main___globals); + 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", "", 97, CPyStatic_main___globals); + 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", "", 97, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL113; } - cpy_r_r140 = CPyStatics[57]; /* '__prepare__' */ + 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[68]; /* '_HexBytesSubclass1' */ - cpy_r_r143 = CPyStatics[57]; /* '__prepare__' */ + 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", "", 97, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL113; } PyObject *cpy_r_r145[2] = {cpy_r_r142, cpy_r_r137}; @@ -2993,7 +2996,7 @@ CPyL26: ; 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", "", 97, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL113; } if (likely(PyDict_Check(cpy_r_r147))) @@ -3007,65 +3010,65 @@ CPyL26: ; CPyL55: ; cpy_r_r150 = PyDict_New(); if (unlikely(cpy_r_r150 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 97, CPyStatic_main___globals); + 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", "", 97, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL114; } - cpy_r_r152 = CPyStatics[68]; /* '_HexBytesSubclass1' */ - cpy_r_r153 = CPyStatics[62]; /* '__annotations__' */ + 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", "", 97, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL114; } - cpy_r_r156 = CPyStatics[63]; /* 'mypyc filler docstring' */ - cpy_r_r157 = CPyStatics[64]; /* '__doc__' */ + 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", "", 97, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL114; } - cpy_r_r160 = CPyStatics[8]; /* 'faster_hexbytes.main' */ - cpy_r_r161 = CPyStatics[65]; /* '__module__' */ + 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", "", 97, CPyStatic_main___globals); + 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", "", 97, CPyStatic_main___globals); + 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[47]; /* 'mypyc_attr' */ + 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", "", 96, CPyStatic_main___globals); + 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[86]; /* ('native_class',) */ + 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", "", 96, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL115; } PyObject *cpy_r_r175[1] = {cpy_r_r166}; @@ -3073,49 +3076,49 @@ CPyL57: ; 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", "", 97, CPyStatic_main___globals); + 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[68]; /* '_HexBytesSubclass1' */ + 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", "", 97, CPyStatic_main___globals); + 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[7]; /* 'HexBytes' */ + 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", "", 99, CPyStatic_main___globals); + 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", "", 99, CPyStatic_main___globals); + 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", "", 99, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL116; } - cpy_r_r189 = CPyStatics[57]; /* '__prepare__' */ + 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[69]; /* '_HexBytesSubclass2' */ - cpy_r_r192 = CPyStatics[57]; /* '__prepare__' */ + 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", "", 99, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL116; } PyObject *cpy_r_r194[2] = {cpy_r_r191, cpy_r_r186}; @@ -3123,7 +3126,7 @@ CPyL57: ; 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", "", 99, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL116; } if (likely(PyDict_Check(cpy_r_r196))) @@ -3137,65 +3140,65 @@ CPyL57: ; CPyL74: ; cpy_r_r199 = PyDict_New(); if (unlikely(cpy_r_r199 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 99, CPyStatic_main___globals); + 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", "", 99, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL117; } - cpy_r_r201 = CPyStatics[69]; /* '_HexBytesSubclass2' */ - cpy_r_r202 = CPyStatics[62]; /* '__annotations__' */ + 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", "", 99, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL117; } - cpy_r_r205 = CPyStatics[63]; /* 'mypyc filler docstring' */ - cpy_r_r206 = CPyStatics[64]; /* '__doc__' */ + 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", "", 99, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL117; } - cpy_r_r209 = CPyStatics[8]; /* 'faster_hexbytes.main' */ - cpy_r_r210 = CPyStatics[65]; /* '__module__' */ + 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", "", 99, CPyStatic_main___globals); + 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", "", 99, CPyStatic_main___globals); + 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[47]; /* 'mypyc_attr' */ + 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", "", 98, CPyStatic_main___globals); + 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[86]; /* ('native_class',) */ + 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", "", 98, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL118; } PyObject *cpy_r_r224[1] = {cpy_r_r215}; @@ -3203,49 +3206,49 @@ CPyL76: ; 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", "", 99, CPyStatic_main___globals); + 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[69]; /* '_HexBytesSubclass2' */ + 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", "", 99, CPyStatic_main___globals); + 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[7]; /* 'HexBytes' */ + 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", "", 101, CPyStatic_main___globals); + 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", "", 101, CPyStatic_main___globals); + 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", "", 101, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL119; } - cpy_r_r238 = CPyStatics[57]; /* '__prepare__' */ + 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[70]; /* '_HexBytesSubclass3' */ - cpy_r_r241 = CPyStatics[57]; /* '__prepare__' */ + 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", "", 101, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL119; } PyObject *cpy_r_r243[2] = {cpy_r_r240, cpy_r_r235}; @@ -3253,7 +3256,7 @@ CPyL76: ; 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", "", 101, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL119; } if (likely(PyDict_Check(cpy_r_r245))) @@ -3267,65 +3270,65 @@ CPyL76: ; CPyL93: ; cpy_r_r248 = PyDict_New(); if (unlikely(cpy_r_r248 == NULL)) { - CPy_AddTraceback("faster_hexbytes/main.py", "", 101, CPyStatic_main___globals); + 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", "", 101, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL120; } - cpy_r_r250 = CPyStatics[70]; /* '_HexBytesSubclass3' */ - cpy_r_r251 = CPyStatics[62]; /* '__annotations__' */ + 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", "", 101, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL120; } - cpy_r_r254 = CPyStatics[63]; /* 'mypyc filler docstring' */ - cpy_r_r255 = CPyStatics[64]; /* '__doc__' */ + 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", "", 101, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL120; } - cpy_r_r258 = CPyStatics[8]; /* 'faster_hexbytes.main' */ - cpy_r_r259 = CPyStatics[65]; /* '__module__' */ + 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", "", 101, CPyStatic_main___globals); + 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", "", 101, CPyStatic_main___globals); + 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[47]; /* 'mypyc_attr' */ + 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", "", 100, CPyStatic_main___globals); + 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[86]; /* ('native_class',) */ + 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", "", 100, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL121; } PyObject *cpy_r_r273[1] = {cpy_r_r264}; @@ -3333,19 +3336,19 @@ CPyL95: ; 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", "", 101, CPyStatic_main___globals); + 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[70]; /* '_HexBytesSubclass3' */ + 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", "", 101, CPyStatic_main___globals); + CPy_AddTraceback("faster_hexbytes/main.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_main___globals); goto CPyL105; } cpy_r_r280 = (PyObject *)CPyType_main____HexBytesSubclass3; @@ -3441,7 +3444,7 @@ int CPyGlobalsInit(void) return 0; } -PyObject *CPyStatics[87]; +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__", diff --git a/build/faster_hexbytes.c b/build/faster_hexbytes.c index c09d246..c0722af 100644 --- a/build/faster_hexbytes.c +++ b/build/faster_hexbytes.c @@ -1,3 +1,6 @@ +#ifndef DIFFCHECK_PLACEHOLDER +#define DIFFCHECK_PLACEHOLDER 0 +#endif #include PyMODINIT_FUNC diff --git a/build/ops.txt b/build/ops.txt index 7a59370..8dfadfc 100644 --- a/build/ops.txt +++ b/build/ops.txt @@ -1,106 +1,3 @@ -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 __new___HexBytes_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object r1 :: bit @@ -1287,6 +1184,109 @@ 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 From 915a16fb1487b0776d7da1e8537c53525fe18396 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Tue, 7 Oct 2025 03:41:32 -0400 Subject: [PATCH 69/70] feat(cicd): only run runners on code changes (#13) --- .github/workflows/benchmark.yaml | 10 ++++++++++ .github/workflows/codspeed.yaml | 10 ++++++++++ .github/workflows/tox.yaml | 10 ++++++++++ 3 files changed, 30 insertions(+) diff --git a/.github/workflows/benchmark.yaml b/.github/workflows/benchmark.yaml index 33b4ce8..761ebb8 100644 --- a/.github/workflows/benchmark.yaml +++ b/.github/workflows/benchmark.yaml @@ -3,8 +3,18 @@ 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: diff --git a/.github/workflows/codspeed.yaml b/.github/workflows/codspeed.yaml index 6448073..621dc47 100644 --- a/.github/workflows/codspeed.yaml +++ b/.github/workflows/codspeed.yaml @@ -3,8 +3,18 @@ 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: diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index e145fb1..45ca152 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -3,8 +3,18 @@ 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 From 5b5cf49f82270bcdf9bb3d27e568058924864f67 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 7 Oct 2025 08:10:57 +0000 Subject: [PATCH 70/70] Update benchmark results [skip ci] --- benchmarks/results/_utils.md | 276 +++++----- benchmarks/results/main.md | 966 +++++++++++++++++------------------ 2 files changed, 621 insertions(+), 621 deletions(-) diff --git a/benchmarks/results/_utils.md b/benchmarks/results/_utils.md index cddf5a2..558a7fa 100644 --- a/benchmarks/results/_utils.md +++ b/benchmarks/results/_utils.md @@ -1,141 +1,141 @@ -#### [faster_hexbytes._utils](https://github.com/BobTheBuidler/faster-hexbytes/blob/benchmark/faster_hexbytes/_utils.py) - [view benchmarks](https://github.com/BobTheBuidler/faster-hexbytes/blob/benchmark/benchmarks/test__utils_benchmarks.py) +#### [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.7693315307804868e-05 | 1.1179726147479144e-05 | 36.81% | 58.26% | 1.58x | ✅ | -| `hexstr_to_bytes['0x'+'0'*128]` | 3.42949906090721e-05 | 2.098034489856244e-05 | 38.82% | 63.46% | 1.63x | ✅ | -| `hexstr_to_bytes['0x'+'00'*64]` | 3.4029689635560134e-05 | 2.10303706868544e-05 | 38.20% | 61.81% | 1.62x | ✅ | -| `hexstr_to_bytes['0x'+'00ff'*16]` | 3.094838328028653e-05 | 1.807462000181124e-05 | 41.60% | 71.23% | 1.71x | ✅ | -| `hexstr_to_bytes['0x'+'0123456789abcdef'*8]` | 3.432770530738586e-05 | 2.0939726654757956e-05 | 39.00% | 63.94% | 1.64x | ✅ | -| `hexstr_to_bytes['0x'+'1'*64]` | 3.106500558142552e-05 | 1.803506739850267e-05 | 41.94% | 72.25% | 1.72x | ✅ | -| `hexstr_to_bytes['0x'+'1234567890abcdef'*8]` | 3.444213332083847e-05 | 2.1062415055709138e-05 | 38.85% | 63.52% | 1.64x | ✅ | -| `hexstr_to_bytes['0x'+'a'*128]` | 3.402123802839552e-05 | 2.1096504577780626e-05 | 37.99% | 61.26% | 1.61x | ✅ | -| `hexstr_to_bytes['0x'+'a1b2c3d4'*8]` | 3.118321973125747e-05 | 1.865736666332591e-05 | 40.17% | 67.14% | 1.67x | ✅ | -| `hexstr_to_bytes['0x'+'b'*2048]` | 0.00013594383303039772 | 0.00011740238816895623 | 13.64% | 15.79% | 1.16x | ✅ | -| `hexstr_to_bytes['0x'+'badc0ffee0ddf00d'*4]` | 3.0637299606844215e-05 | 1.825061606833408e-05 | 40.43% | 67.87% | 1.68x | ✅ | -| `hexstr_to_bytes['0x'+'beef'*16]` | 3.0686441614538446e-05 | 1.828964146387517e-05 | 40.40% | 67.78% | 1.68x | ✅ | -| `hexstr_to_bytes['0x'+'c'*1024]` | 8.930193709352504e-05 | 7.109606211638662e-05 | 20.39% | 25.61% | 1.26x | ✅ | -| `hexstr_to_bytes['0x'+'cafebabe'*8]` | 3.088379314855554e-05 | 1.8427330656680643e-05 | 40.33% | 67.60% | 1.68x | ✅ | -| `hexstr_to_bytes['0x'+'d'*512]` | 5.7096419255965127e-05 | 4.083693236247332e-05 | 28.48% | 39.82% | 1.40x | ✅ | -| `hexstr_to_bytes['0x'+'dead'*16]` | 3.058232145729629e-05 | 1.809661975645168e-05 | 40.83% | 68.99% | 1.69x | ✅ | -| `hexstr_to_bytes['0x'+'e'*256]` | 4.3404514225927844e-05 | 2.765456002913683e-05 | 36.29% | 56.95% | 1.57x | ✅ | -| `hexstr_to_bytes['0x'+'f'*128]` | 3.399261691057168e-05 | 2.222686285822979e-05 | 34.61% | 52.93% | 1.53x | ✅ | -| `hexstr_to_bytes['0x'+'f'*64]` | 3.1021508877018215e-05 | 1.8116641999804634e-05 | 41.60% | 71.23% | 1.71x | ✅ | -| `hexstr_to_bytes['0x'+'facefeed'*8]` | 3.080530283390321e-05 | 1.836125208505399e-05 | 40.40% | 67.77% | 1.68x | ✅ | -| `hexstr_to_bytes['0x'+'ff'*32]` | 3.025273538705345e-05 | 1.869490905427472e-05 | 38.20% | 61.82% | 1.62x | ✅ | -| `hexstr_to_bytes['0x'+'ff00'*16]` | 3.133593755440466e-05 | 1.793547693437449e-05 | 42.76% | 74.71% | 1.75x | ✅ | -| `hexstr_to_bytes['0x']` | 2.2363566556968745e-05 | 1.0721175914161055e-05 | 52.06% | 108.59% | 2.09x | ✅ | -| `hexstr_to_bytes['0x0']` | 3.117668463108531e-05 | 1.8295366577069213e-05 | 41.32% | 70.41% | 1.70x | ✅ | -| `hexstr_to_bytes['0x1']` | 3.0849555815962966e-05 | 1.8261551169755883e-05 | 40.80% | 68.93% | 1.69x | ✅ | -| `hexstr_to_bytes['0x1234']` | 2.8017224899503598e-05 | 1.6290132930728818e-05 | 41.86% | 71.99% | 1.72x | ✅ | -| `hexstr_to_bytes['0xCAFEBABE']` | 2.8630167761260635e-05 | 1.590381517649548e-05 | 44.45% | 80.02% | 1.80x | ✅ | -| `hexstr_to_bytes['0xabcdef']` | 2.819579268732196e-05 | 1.6022231111650803e-05 | 43.18% | 75.98% | 1.76x | ✅ | -| `hexstr_to_bytes['0xdeadbeef']` | 2.830248157006902e-05 | 1.585293612257558e-05 | 43.99% | 78.53% | 1.79x | ✅ | -| `hexstr_to_bytes['deadbeef']` | 2.1769765855138907e-05 | 1.4235579165167571e-05 | 34.61% | 52.93% | 1.53x | ✅ | -| `to_bytes['']` | 2.780713012713541e-05 | 1.2309232769289748e-05 | 55.73% | 125.90% | 2.26x | ✅ | -| `to_bytes['0x'+'00'*64]` | 4.614754749205394e-05 | 2.454348694205276e-05 | 46.82% | 88.02% | 1.88x | ✅ | -| `to_bytes['0x'+'a'*128]` | 4.578380867751802e-05 | 2.2843051102385115e-05 | 50.11% | 100.43% | 2.00x | ✅ | -| `to_bytes['0x'+'ff'*32]` | 4.2892556366788844e-05 | 2.0060250794027318e-05 | 53.23% | 113.82% | 2.14x | ✅ | -| `to_bytes['0x']` | 3.378070519013953e-05 | 1.2405538866200987e-05 | 63.28% | 172.30% | 2.72x | ✅ | -| `to_bytes['0x1234']` | 4.0135614389222814e-05 | 1.7331320939841e-05 | 56.82% | 131.58% | 2.32x | ✅ | -| `to_bytes['0xCAFEBABE']` | 4.028950128859023e-05 | 1.7608736971127636e-05 | 56.29% | 128.80% | 2.29x | ✅ | -| `to_bytes['0xabcdef']` | 4.033539702017461e-05 | 1.7413172587315903e-05 | 56.83% | 131.64% | 2.32x | ✅ | -| `to_bytes['0xdeadbeef']` | 4.013742988293151e-05 | 1.753887938858019e-05 | 56.30% | 128.85% | 2.29x | ✅ | -| `to_bytes['abc']` | 3.626267484598067e-05 | 1.9475589274551575e-05 | 46.29% | 86.20% | 1.86x | ✅ | -| `to_bytes['deadbeef']` | 3.2121970134094524e-05 | 1.4998967326784364e-05 | 53.31% | 114.16% | 2.14x | ✅ | -| `to_bytes[0-9]` | 6.3886084044368e-06 | 3.6301764321770105e-06 | 43.18% | 75.99% | 1.76x | ✅ | -| `to_bytes[0]` | 7.379821878600025e-05 | 3.0514048254667094e-05 | 58.65% | 141.85% | 2.42x | ✅ | -| `to_bytes[123456]` | 7.73908812451048e-05 | 3.575842943020024e-05 | 53.80% | 116.43% | 2.16x | ✅ | -| `to_bytes[2**16]` | 7.617986899797664e-05 | 3.527787514997935e-05 | 53.69% | 115.94% | 2.16x | ✅ | -| `to_bytes[2**256-1]` | 8.129447794758294e-05 | 4.0483949767541644e-05 | 50.20% | 100.81% | 2.01x | ✅ | -| `to_bytes[2**32]` | 7.885789630365754e-05 | 3.807714350478118e-05 | 51.71% | 107.10% | 2.07x | ✅ | -| `to_bytes[2**64]` | 8.069210213483589e-05 | 3.965815884713019e-05 | 50.85% | 103.47% | 2.03x | ✅ | -| `to_bytes[2**8]` | 7.60528725562803e-05 | 3.317653912689118e-05 | 56.38% | 129.24% | 2.29x | ✅ | -| `to_bytes[4-byte pattern]` | 5.966323180854022e-06 | 3.3885955799150795e-06 | 43.20% | 76.07% | 1.76x | ✅ | -| `to_bytes[False]` | 2.132333374780846e-05 | 4.322555878144883e-06 | 79.73% | 393.30% | 4.93x | ✅ | -| `to_bytes[True]` | 2.114009323563744e-05 | 4.474505459519339e-06 | 78.83% | 372.46% | 4.72x | ✅ | -| `to_bytes[all byte values]` | 6.388727853404534e-06 | 3.6321036172973787e-06 | 43.15% | 75.90% | 1.76x | ✅ | -| `to_bytes[alternating 0x00/0xff]` | 6.363086431103152e-06 | 3.4449100293139135e-06 | 45.86% | 84.71% | 1.85x | ✅ | -| `to_bytes[alternating 0xaa/0x55]` | 6.278620315055821e-06 | 3.535981761329247e-06 | 43.68% | 77.56% | 1.78x | ✅ | -| `to_bytes[ascii sentence]` | 6.385267134108629e-06 | 3.7213794053924145e-06 | 41.72% | 71.58% | 1.72x | ✅ | -| `to_bytes[b'']` | 6.10807762546999e-06 | 3.559441642548437e-06 | 41.73% | 71.60% | 1.72x | ✅ | -| `to_bytes[b'\\x00'*32]` | 6.1997821267900955e-06 | 3.7227266437959667e-06 | 39.95% | 66.54% | 1.67x | ✅ | -| `to_bytes[b'\\x00\\xff\\x00\\xff']` | 6.115080140454961e-06 | 3.6294043971970026e-06 | 40.65% | 68.49% | 1.68x | ✅ | -| `to_bytes[b'\\x01'*100]` | 6.38729320124322e-06 | 3.629548274374021e-06 | 43.18% | 75.98% | 1.76x | ✅ | -| `to_bytes[b'\\x01'*2048]` | 6.392970547909741e-06 | 3.5681287886529697e-06 | 44.19% | 79.17% | 1.79x | ✅ | -| `to_bytes[b'\\x01\\x02\\x03']` | 6.214807194428287e-06 | 3.5724200907566754e-06 | 42.52% | 73.97% | 1.74x | ✅ | -| `to_bytes[b'\\x10\\x20\\x30\\x40\\x50']` | 6.384759732087906e-06 | 3.4718455445162805e-06 | 45.62% | 83.90% | 1.84x | ✅ | -| `to_bytes[b'\\x7f'*8]` | 6.2221944530742285e-06 | 3.6299630009677656e-06 | 41.66% | 71.41% | 1.71x | ✅ | -| `to_bytes[b'\\x80'*8]` | 6.154746823977371e-06 | 3.5098569762158247e-06 | 42.97% | 75.36% | 1.75x | ✅ | -| `to_bytes[b'\\xde\\xad\\xbe\\xef']` | 6.118508096629166e-06 | 3.5327114331565147e-06 | 42.26% | 73.20% | 1.73x | ✅ | -| `to_bytes[b'\\xff'*64]` | 6.228611346948233e-06 | 3.5638385534057674e-06 | 42.78% | 74.77% | 1.75x | ✅ | -| `to_bytes[b'a'*1024]` | 6.214476654822796e-06 | 3.6405793911024955e-06 | 41.42% | 70.70% | 1.71x | ✅ | -| `to_bytes[b'abc']` | 5.704947810781707e-06 | 3.6286094943273793e-06 | 36.40% | 57.22% | 1.57x | ✅ | -| `to_bytes[bytearray(0-9)]` | 2.8385540980501474e-05 | 1.3892159525838066e-05 | 51.06% | 104.33% | 2.04x | ✅ | -| `to_bytes[bytearray(4-byte pattern)]` | 2.827050900870094e-05 | 1.4056222794783555e-05 | 50.28% | 101.12% | 2.01x | ✅ | -| `to_bytes[bytearray(all byte values)]` | 2.877292936670269e-05 | 1.435422533320354e-05 | 50.11% | 100.45% | 2.00x | ✅ | -| `to_bytes[bytearray(alternating 0x00/0xff)]` | 2.8227929229195593e-05 | 1.3651875261692757e-05 | 51.64% | 106.77% | 2.07x | ✅ | -| `to_bytes[bytearray(alternating 0xaa/0x55)]` | 2.837463577403303e-05 | 1.4085501772100954e-05 | 50.36% | 101.45% | 2.01x | ✅ | -| `to_bytes[bytearray(ascii sentence)]` | 2.788046431872048e-05 | 1.4073893727957965e-05 | 49.52% | 98.10% | 1.98x | ✅ | -| `to_bytes[bytearray(b'')]` | 2.5972620905868233e-05 | 1.2685871938856117e-05 | 51.16% | 104.74% | 2.05x | ✅ | -| `to_bytes[bytearray(b'\\x00'*32)]` | 2.790329559512333e-05 | 1.403080114449928e-05 | 49.72% | 98.87% | 1.99x | ✅ | -| `to_bytes[bytearray(b'\\x00\\xff\\x00\\xff')]` | 2.7745585095988548e-05 | 1.4024106217358874e-05 | 49.45% | 97.84% | 1.98x | ✅ | -| `to_bytes[bytearray(b'\\x01'*100)]` | 2.8536359978812884e-05 | 1.4236424049013974e-05 | 50.11% | 100.45% | 2.00x | ✅ | -| `to_bytes[bytearray(b'\\x01'*2048)]` | 3.549077378005222e-05 | 1.9352766224829574e-05 | 45.47% | 83.39% | 1.83x | ✅ | -| `to_bytes[bytearray(b'\\x01\\x02\\x03')]` | 2.8101052165112413e-05 | 1.4292128556009155e-05 | 49.14% | 96.62% | 1.97x | ✅ | -| `to_bytes[bytearray(b'\\x10\\x20\\x30\\x40\\x50')]` | 2.7661397342967836e-05 | 1.4095613005042919e-05 | 49.04% | 96.24% | 1.96x | ✅ | -| `to_bytes[bytearray(b'\\x7f'*8)]` | 2.725931521432537e-05 | 1.3800682471510037e-05 | 49.37% | 97.52% | 1.98x | ✅ | -| `to_bytes[bytearray(b'\\x80'*8)]` | 2.8590031839184632e-05 | 1.4021589244572647e-05 | 50.96% | 103.90% | 2.04x | ✅ | -| `to_bytes[bytearray(b'\\xde\\xad\\xbe\\xef')]` | 2.7673809875166307e-05 | 1.3955245016922358e-05 | 49.57% | 98.30% | 1.98x | ✅ | -| `to_bytes[bytearray(b'\\xff'*64)]` | 2.7825869941964144e-05 | 1.397535630887856e-05 | 49.78% | 99.11% | 1.99x | ✅ | -| `to_bytes[bytearray(b'a'*1024)]` | 3.4580409459484653e-05 | 1.8673202446672093e-05 | 46.00% | 85.19% | 1.85x | ✅ | -| `to_bytes[bytearray(b'abc')]` | 2.7632051275317663e-05 | 1.4212278275687856e-05 | 48.57% | 94.42% | 1.94x | ✅ | -| `to_bytes[bytearray(long alternating)]` | 3.447633488580355e-05 | 1.863387225839248e-05 | 45.95% | 85.02% | 1.85x | ✅ | -| `to_bytes[bytearray(mixed pattern)]` | 2.8541322877722866e-05 | 1.4195507938501473e-05 | 50.26% | 101.06% | 2.01x | ✅ | -| `to_bytes[bytearray(multiples of 0x10)]` | 2.8730667094271124e-05 | 1.4011019797634606e-05 | 51.23% | 105.06% | 2.05x | ✅ | -| `to_bytes[bytearray(palindrome ascii)]` | 2.8401192649128307e-05 | 1.3961644776858775e-05 | 50.84% | 103.42% | 2.03x | ✅ | -| `to_bytes[bytearray(palindrome numeric)]` | 2.805100416648689e-05 | 1.4152590803546867e-05 | 49.55% | 98.20% | 1.98x | ✅ | -| `to_bytes[bytearray(palindrome)]` | 2.7361673603877895e-05 | 1.411429298192429e-05 | 48.42% | 93.86% | 1.94x | ✅ | -| `to_bytes[bytearray(repeated 0-9)]` | 2.8494565334918126e-05 | 1.4258424138299958e-05 | 49.96% | 99.84% | 2.00x | ✅ | -| `to_bytes[bytearray(single 0xff)]` | 2.8234466593201184e-05 | 1.3801473578009802e-05 | 51.12% | 104.58% | 2.05x | ✅ | -| `to_bytes[bytearray(single null byte)]` | 2.8434517722019846e-05 | 1.3809952582861235e-05 | 51.43% | 105.90% | 2.06x | ✅ | -| `to_bytes[bytearray(two patterns)]` | 2.836216679184966e-05 | 1.3887588637424222e-05 | 51.03% | 104.23% | 2.04x | ✅ | -| `to_bytes[long alternating]` | 6.353790402607213e-06 | 3.5938990087545537e-06 | 43.44% | 76.79% | 1.77x | ✅ | -| `to_bytes[memoryview(0-9)]` | 4.191141964546983e-05 | 1.7061112356892058e-05 | 59.29% | 145.65% | 2.46x | ✅ | -| `to_bytes[memoryview(4-byte pattern)]` | 4.227527549170472e-05 | 1.785782064892619e-05 | 57.76% | 136.73% | 2.37x | ✅ | -| `to_bytes[memoryview(all byte values)]` | 4.25000108585221e-05 | 1.7688601774026213e-05 | 58.38% | 140.27% | 2.40x | ✅ | -| `to_bytes[memoryview(alternating 0x00/0xff)]` | 4.1347704048452746e-05 | 1.6650846971237402e-05 | 59.73% | 148.32% | 2.48x | ✅ | -| `to_bytes[memoryview(alternating 0xaa/0x55)]` | 4.171208060914525e-05 | 1.675602408003079e-05 | 59.83% | 148.94% | 2.49x | ✅ | -| `to_bytes[memoryview(ascii sentence)]` | 4.166324952645984e-05 | 1.709207709767455e-05 | 58.98% | 143.76% | 2.44x | ✅ | -| `to_bytes[memoryview(b'')]` | 3.925414926485738e-05 | 1.5303932766174733e-05 | 61.01% | 156.50% | 2.56x | ✅ | -| `to_bytes[memoryview(b'\\x00'*32)]` | 4.1375511773526405e-05 | 1.6976747870806958e-05 | 58.97% | 143.72% | 2.44x | ✅ | -| `to_bytes[memoryview(b'\\x00\\xff\\x00\\xff')]` | 4.106893288361651e-05 | 1.7061131875227936e-05 | 58.46% | 140.72% | 2.41x | ✅ | -| `to_bytes[memoryview(b'\\x01'*100)]` | 4.193922634521223e-05 | 1.7745782258368427e-05 | 57.69% | 136.33% | 2.36x | ✅ | -| `to_bytes[memoryview(b'\\x01'*2048)]` | 5.0798682929570083e-05 | 2.40390666370428e-05 | 52.68% | 111.32% | 2.11x | ✅ | -| `to_bytes[memoryview(b'\\x01\\x02\\x03')]` | 4.036702557146768e-05 | 1.7250564311840054e-05 | 57.27% | 134.00% | 2.34x | ✅ | -| `to_bytes[memoryview(b'\\x10\\x20\\x30\\x40\\x50')]` | 4.175508032041267e-05 | 1.6957717517602734e-05 | 59.39% | 146.23% | 2.46x | ✅ | -| `to_bytes[memoryview(b'\\x7f'*8)]` | 4.1358438818942784e-05 | 1.6817791110631697e-05 | 59.34% | 145.92% | 2.46x | ✅ | -| `to_bytes[memoryview(b'\\x80'*8)]` | 4.203092161038334e-05 | 1.681154500200111e-05 | 60.00% | 150.01% | 2.50x | ✅ | -| `to_bytes[memoryview(b'\\xde\\xad\\xbe\\xef')]` | 4.231867737850461e-05 | 1.6846002165597455e-05 | 60.19% | 151.21% | 2.51x | ✅ | -| `to_bytes[memoryview(b'\\xff'*64)]` | 4.126073396736014e-05 | 1.6694308190545488e-05 | 59.54% | 147.15% | 2.47x | ✅ | -| `to_bytes[memoryview(b'a'*1024)]` | 4.88048523792244e-05 | 2.4008626930621554e-05 | 50.81% | 103.28% | 2.03x | ✅ | -| `to_bytes[memoryview(b'abc')]` | 4.134610001372583e-05 | 1.7269193990729754e-05 | 58.23% | 139.42% | 2.39x | ✅ | -| `to_bytes[memoryview(long alternating)]` | 4.8406942144499424e-05 | 2.388143899713461e-05 | 50.67% | 102.70% | 2.03x | ✅ | -| `to_bytes[memoryview(mixed pattern)]` | 4.167505874201827e-05 | 1.7698671546729557e-05 | 57.53% | 135.47% | 2.35x | ✅ | -| `to_bytes[memoryview(multiples of 0x10)]` | 4.2573899493451105e-05 | 1.705716143319723e-05 | 59.94% | 149.60% | 2.50x | ✅ | -| `to_bytes[memoryview(palindrome ascii)]` | 4.147093203068994e-05 | 1.6858821327193028e-05 | 59.35% | 145.99% | 2.46x | ✅ | -| `to_bytes[memoryview(palindrome numeric)]` | 4.2052385986215005e-05 | 1.6783240695512243e-05 | 60.09% | 150.56% | 2.51x | ✅ | -| `to_bytes[memoryview(palindrome)]` | 4.010310828456553e-05 | 1.6841586810144283e-05 | 58.00% | 138.12% | 2.38x | ✅ | -| `to_bytes[memoryview(repeated 0-9)]` | 4.2346341955859134e-05 | 1.7627392408451933e-05 | 58.37% | 140.23% | 2.40x | ✅ | -| `to_bytes[memoryview(single 0xff)]` | 4.154646686337471e-05 | 1.708420634946452e-05 | 58.88% | 143.19% | 2.43x | ✅ | -| `to_bytes[memoryview(single null byte)]` | 4.1426186115767904e-05 | 1.7216447723124524e-05 | 58.44% | 140.62% | 2.41x | ✅ | -| `to_bytes[memoryview(two patterns)]` | 4.120532411573023e-05 | 1.6795418517469898e-05 | 59.24% | 145.34% | 2.45x | ✅ | -| `to_bytes[mixed pattern]` | 6.402295260899727e-06 | 3.6240499846615196e-06 | 43.39% | 76.66% | 1.77x | ✅ | -| `to_bytes[multiples of 0x10]` | 6.11021314345847e-06 | 3.5831417482492563e-06 | 41.36% | 70.53% | 1.71x | ✅ | -| `to_bytes[palindrome ascii]` | 6.034686767709764e-06 | 3.5377684971786242e-06 | 41.38% | 70.58% | 1.71x | ✅ | -| `to_bytes[palindrome numeric]` | 6.402815719286604e-06 | 3.659680142558091e-06 | 42.84% | 74.96% | 1.75x | ✅ | -| `to_bytes[palindrome]` | 5.802467693826409e-06 | 3.521160495735191e-06 | 39.32% | 64.79% | 1.65x | ✅ | -| `to_bytes[repeated 0-9]` | 6.383479853505014e-06 | 3.638034291718348e-06 | 43.01% | 75.47% | 1.75x | ✅ | -| `to_bytes[single 0xff]` | 6.267069994516826e-06 | 3.559259039534453e-06 | 43.21% | 76.08% | 1.76x | ✅ | -| `to_bytes[single null byte]` | 6.26625804427524e-06 | 3.271624181759306e-06 | 47.79% | 91.53% | 1.92x | ✅ | -| `to_bytes[two patterns]` | 6.347030519900153e-06 | 3.5394506816199115e-06 | 44.23% | 79.32% | 1.79x | ✅ | +| `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 index b4be1f4..67f7743 100644 --- a/benchmarks/results/main.md +++ b/benchmarks/results/main.md @@ -1,486 +1,486 @@ -#### [faster_hexbytes.main](https://github.com/BobTheBuidler/faster-hexbytes/blob/benchmark/faster_hexbytes/main.py) - [view benchmarks](https://github.com/BobTheBuidler/faster-hexbytes/blob/benchmark/benchmarks/test_main_benchmarks.py) +#### [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.4847447452029246e-05 | 2.3450026731823607e-05 | 5.62% | 5.96% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-4-byte pattern]` | 2.446805682924332e-05 | 2.3635641231548687e-05 | 3.40% | 3.52% | 1.04x | ✅ | -| `hexbytes_getitem_index[-1-all byte values]` | 2.4726612057580454e-05 | 2.3407566330406905e-05 | 5.33% | 5.64% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-alternating 0x00/0xff]` | 2.4731667416142e-05 | 2.3283497082720465e-05 | 5.86% | 6.22% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-alternating 0xaa/0x55]` | 2.4523115479161836e-05 | 2.3346323921959994e-05 | 4.80% | 5.04% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-ascii sentence]` | 2.471176627058649e-05 | 2.3615962469828527e-05 | 4.43% | 4.64% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-b'\\x00'*32]` | 2.4777311257616818e-05 | 2.3405050535681556e-05 | 5.54% | 5.86% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-b'\\x00\\xff\\x00\\xff']` | 2.4313481344212053e-05 | 2.3204503403589972e-05 | 4.56% | 4.78% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-b'\\x01'*100]` | 2.468310354706276e-05 | 2.327476042499668e-05 | 5.71% | 6.05% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-b'\\x01'*2048]` | 2.4854226475343243e-05 | 2.3390127621197537e-05 | 5.89% | 6.26% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-b'\\x01\\x02\\x03']` | 2.4745279930320675e-05 | 2.3522761413737913e-05 | 4.94% | 5.20% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-b'\\x10\\x20\\x30\\x40\\x50']` | 2.438506663016707e-05 | 2.3257755613599015e-05 | 4.62% | 4.85% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-b'\\x7f'*8]` | 2.4743313419518356e-05 | 2.3370369649475358e-05 | 5.55% | 5.87% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-b'\\x80'*8]` | 2.4816026228816605e-05 | 2.3249313657766363e-05 | 6.31% | 6.74% | 1.07x | ✅ | -| `hexbytes_getitem_index[-1-b'\\xde\\xad\\xbe\\xef']` | 2.448254310611167e-05 | 2.3316949833370263e-05 | 4.76% | 5.00% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-b'\\xff'*64]` | 2.4849436712534857e-05 | 2.3344878336245734e-05 | 6.05% | 6.44% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-b'a'*1024]` | 2.493238498788441e-05 | 2.3606790961815634e-05 | 5.32% | 5.62% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-b'abc']` | 2.4834496919024717e-05 | 2.3382304411471888e-05 | 5.85% | 6.21% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-long alternating]` | 2.4615057704326276e-05 | 2.3430983714349e-05 | 4.81% | 5.05% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-mixed pattern]` | 2.4671778626251292e-05 | 2.3627064998301808e-05 | 4.23% | 4.42% | 1.04x | ✅ | -| `hexbytes_getitem_index[-1-multiples of 0x10]` | 2.468829805610535e-05 | 2.3326285352224695e-05 | 5.52% | 5.84% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-palindrome ascii]` | 2.4370598961263974e-05 | 2.338947068419359e-05 | 4.03% | 4.19% | 1.04x | ✅ | -| `hexbytes_getitem_index[-1-palindrome numeric]` | 2.4579864556403647e-05 | 2.3370869518498163e-05 | 4.92% | 5.17% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-palindrome]` | 2.4879236943731623e-05 | 2.3387243476769648e-05 | 6.00% | 6.38% | 1.06x | ✅ | -| `hexbytes_getitem_index[-1-repeated 0-9]` | 2.448997201236898e-05 | 2.3253474233650765e-05 | 5.05% | 5.32% | 1.05x | ✅ | -| `hexbytes_getitem_index[-1-two patterns]` | 2.450192796439518e-05 | 2.357708117878136e-05 | 3.77% | 3.92% | 1.04x | ✅ | -| `hexbytes_getitem_index[0-0-9]` | 2.3640609440231097e-05 | 2.232804370059225e-05 | 5.55% | 5.88% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-4-byte pattern]` | 2.373320584882109e-05 | 2.233125115448439e-05 | 5.91% | 6.28% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-all byte values]` | 2.3559061122321206e-05 | 2.2250773621945793e-05 | 5.55% | 5.88% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-alternating 0x00/0xff]` | 2.3749435700519763e-05 | 2.218071530181339e-05 | 6.61% | 7.07% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-alternating 0xaa/0x55]` | 2.3719266900758352e-05 | 2.2353831626638472e-05 | 5.76% | 6.11% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-ascii sentence]` | 2.3597481287196645e-05 | 2.2091971995881697e-05 | 6.38% | 6.81% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-b'\\x00'*32]` | 2.392226984110175e-05 | 2.2037988705510813e-05 | 7.88% | 8.55% | 1.09x | ✅ | -| `hexbytes_getitem_index[0-b'\\x00\\xff\\x00\\xff']` | 2.3727784820388614e-05 | 2.2021295173813944e-05 | 7.19% | 7.75% | 1.08x | ✅ | -| `hexbytes_getitem_index[0-b'\\x01'*100]` | 2.3659152481324694e-05 | 2.2252363327119516e-05 | 5.95% | 6.32% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-b'\\x01'*2048]` | 2.3578475937046213e-05 | 2.230988678238333e-05 | 5.38% | 5.69% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-b'\\x01\\x02\\x03']` | 2.3631310564377923e-05 | 2.2118711270966876e-05 | 6.40% | 6.84% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-b'\\x10\\x20\\x30\\x40\\x50']` | 2.372311879146398e-05 | 2.213856237305192e-05 | 6.68% | 7.16% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-b'\\x7f'*8]` | 2.3915516289643552e-05 | 2.2307433582913363e-05 | 6.72% | 7.21% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-b'\\x80'*8]` | 2.3735412525488777e-05 | 2.2230167485098905e-05 | 6.34% | 6.77% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-b'\\xde\\xad\\xbe\\xef']` | 2.3683889844274444e-05 | 2.2163847819654035e-05 | 6.42% | 6.86% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-b'\\xff'*64]` | 2.4175792186616108e-05 | 2.200889907538998e-05 | 8.96% | 9.85% | 1.10x | ✅ | -| `hexbytes_getitem_index[0-b'a'*1024]` | 2.3862376567425472e-05 | 2.2006472774346828e-05 | 7.78% | 8.43% | 1.08x | ✅ | -| `hexbytes_getitem_index[0-b'abc']` | 2.3732148887069292e-05 | 2.2575495507843222e-05 | 4.87% | 5.12% | 1.05x | ✅ | -| `hexbytes_getitem_index[0-long alternating]` | 2.3670516671074392e-05 | 2.2302816885162254e-05 | 5.78% | 6.13% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-mixed pattern]` | 2.369279636677286e-05 | 2.1967241132713774e-05 | 7.28% | 7.86% | 1.08x | ✅ | -| `hexbytes_getitem_index[0-multiples of 0x10]` | 2.3713163133561152e-05 | 2.2395580512059475e-05 | 5.56% | 5.88% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-palindrome ascii]` | 2.372535189391524e-05 | 2.2258396730235407e-05 | 6.18% | 6.59% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-palindrome numeric]` | 2.375859390888847e-05 | 2.2285298064844566e-05 | 6.20% | 6.61% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-palindrome]` | 2.363382163680642e-05 | 2.2135741423325648e-05 | 6.34% | 6.77% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-repeated 0-9]` | 2.3882651063446776e-05 | 2.2259791641842352e-05 | 6.80% | 7.29% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-single 0xff]` | 2.3767333200041022e-05 | 2.2120169400764797e-05 | 6.93% | 7.45% | 1.07x | ✅ | -| `hexbytes_getitem_index[0-single null byte]` | 2.3618790092504198e-05 | 2.2262308923352927e-05 | 5.74% | 6.09% | 1.06x | ✅ | -| `hexbytes_getitem_index[0-two patterns]` | 2.365909050841332e-05 | 2.2210445110527486e-05 | 6.12% | 6.52% | 1.07x | ✅ | -| `hexbytes_getitem_index[1-0-9]` | 2.350437963646178e-05 | 2.230597783626155e-05 | 5.10% | 5.37% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-4-byte pattern]` | 2.3388753001021146e-05 | 2.241563514334635e-05 | 4.16% | 4.34% | 1.04x | ✅ | -| `hexbytes_getitem_index[1-all byte values]` | 2.3389290477161366e-05 | 2.222879750713185e-05 | 4.96% | 5.22% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-alternating 0x00/0xff]` | 2.3624362951330394e-05 | 2.228589793267534e-05 | 5.67% | 6.01% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-alternating 0xaa/0x55]` | 2.3597960178016714e-05 | 2.2363680838750865e-05 | 5.23% | 5.52% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-ascii sentence]` | 2.3531461388181766e-05 | 2.2335075747968907e-05 | 5.08% | 5.36% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-b'\\x00'*32]` | 2.3747036836208635e-05 | 2.2402921023370407e-05 | 5.66% | 6.00% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-b'\\x00\\xff\\x00\\xff']` | 2.359141030040157e-05 | 2.2419787480451866e-05 | 4.97% | 5.23% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-b'\\x01'*100]` | 2.351381044957054e-05 | 2.2326575628342087e-05 | 5.05% | 5.32% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-b'\\x01'*2048]` | 2.3430996963478045e-05 | 2.2274605783180455e-05 | 4.94% | 5.19% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-b'\\x01\\x02\\x03']` | 2.3524676320574997e-05 | 2.2310255654855533e-05 | 5.16% | 5.44% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3733780166228564e-05 | 2.2327814863199725e-05 | 5.92% | 6.30% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-b'\\x7f'*8]` | 2.3687369965297325e-05 | 2.240640951745013e-05 | 5.41% | 5.72% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-b'\\x80'*8]` | 2.3397852464771586e-05 | 2.192985444328968e-05 | 6.27% | 6.69% | 1.07x | ✅ | -| `hexbytes_getitem_index[1-b'\\xde\\xad\\xbe\\xef']` | 2.368834322710453e-05 | 2.2273048897882523e-05 | 5.97% | 6.35% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-b'\\xff'*64]` | 2.3485814293986674e-05 | 2.231628684523511e-05 | 4.98% | 5.24% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-b'a'*1024]` | 2.386470804413667e-05 | 2.2281061209550367e-05 | 6.64% | 7.11% | 1.07x | ✅ | -| `hexbytes_getitem_index[1-b'abc']` | 2.3691218604520744e-05 | 2.2422567641292406e-05 | 5.35% | 5.66% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-long alternating]` | 2.3648119368974904e-05 | 2.2379031486075737e-05 | 5.37% | 5.67% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-mixed pattern]` | 2.347146341953654e-05 | 2.229130324896944e-05 | 5.03% | 5.29% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-multiples of 0x10]` | 2.353816276859851e-05 | 2.2144607709767796e-05 | 5.92% | 6.29% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-palindrome ascii]` | 2.3612440878305855e-05 | 2.2357479185841583e-05 | 5.31% | 5.61% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-palindrome numeric]` | 2.3520370890261427e-05 | 2.2218627957983257e-05 | 5.53% | 5.86% | 1.06x | ✅ | -| `hexbytes_getitem_index[1-palindrome]` | 2.3657794497085767e-05 | 2.256005699098937e-05 | 4.64% | 4.87% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-repeated 0-9]` | 2.343486460477775e-05 | 2.2357192532938336e-05 | 4.60% | 4.82% | 1.05x | ✅ | -| `hexbytes_getitem_index[1-two patterns]` | 2.3571511712386594e-05 | 2.2294920635925086e-05 | 5.42% | 5.73% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-0-9]` | 2.376859702714776e-05 | 2.240866077092658e-05 | 5.72% | 6.07% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-4-byte pattern]` | 2.3971286041117216e-05 | 2.232290985420918e-05 | 6.88% | 7.38% | 1.07x | ✅ | -| `hexbytes_getitem_index[2-all byte values]` | 2.3814855939904812e-05 | 2.2196273233205883e-05 | 6.80% | 7.29% | 1.07x | ✅ | -| `hexbytes_getitem_index[2-alternating 0x00/0xff]` | 2.390055381360492e-05 | 2.2330467329889835e-05 | 6.57% | 7.03% | 1.07x | ✅ | -| `hexbytes_getitem_index[2-alternating 0xaa/0x55]` | 2.3807921178646178e-05 | 2.2431680109115197e-05 | 5.78% | 6.14% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-ascii sentence]` | 2.3365220473568995e-05 | 2.2343897980482263e-05 | 4.37% | 4.57% | 1.05x | ✅ | -| `hexbytes_getitem_index[2-b'\\x00'*32]` | 2.3375625650513347e-05 | 2.2390547339726867e-05 | 4.21% | 4.40% | 1.04x | ✅ | -| `hexbytes_getitem_index[2-b'\\x00\\xff\\x00\\xff']` | 2.350530882275377e-05 | 2.218305857151874e-05 | 5.63% | 5.96% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-b'\\x01'*100]` | 2.3425987917706524e-05 | 2.2096632828754697e-05 | 5.67% | 6.02% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-b'\\x01'*2048]` | 2.3927392356409264e-05 | 2.2239041943430718e-05 | 7.06% | 7.59% | 1.08x | ✅ | -| `hexbytes_getitem_index[2-b'\\x01\\x02\\x03']` | 2.3640994193771224e-05 | 2.2206297555999423e-05 | 6.07% | 6.46% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-b'\\x10\\x20\\x30\\x40\\x50']` | 2.374901494471697e-05 | 2.2245854974556628e-05 | 6.33% | 6.76% | 1.07x | ✅ | -| `hexbytes_getitem_index[2-b'\\x7f'*8]` | 2.3410950031940884e-05 | 2.1972938435673387e-05 | 6.14% | 6.54% | 1.07x | ✅ | -| `hexbytes_getitem_index[2-b'\\x80'*8]` | 2.3365199463743537e-05 | 2.22919694642195e-05 | 4.59% | 4.81% | 1.05x | ✅ | -| `hexbytes_getitem_index[2-b'\\xde\\xad\\xbe\\xef']` | 2.365441097718043e-05 | 2.2245648112737955e-05 | 5.96% | 6.33% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-b'\\xff'*64]` | 2.35864065938133e-05 | 2.231155832021235e-05 | 5.41% | 5.71% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-b'a'*1024]` | 2.323605423398757e-05 | 2.4404525747935898e-05 | -5.03% | -4.79% | 0.95x | ❌ | -| `hexbytes_getitem_index[2-b'abc']` | 2.3722461264859212e-05 | 2.2385468150396267e-05 | 5.64% | 5.97% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-long alternating]` | 2.3847633974548234e-05 | 2.2236601070996807e-05 | 6.76% | 7.24% | 1.07x | ✅ | -| `hexbytes_getitem_index[2-mixed pattern]` | 2.3826645668796012e-05 | 2.2248675041882893e-05 | 6.62% | 7.09% | 1.07x | ✅ | -| `hexbytes_getitem_index[2-multiples of 0x10]` | 2.3607274029087297e-05 | 2.238016502011036e-05 | 5.20% | 5.48% | 1.05x | ✅ | -| `hexbytes_getitem_index[2-palindrome ascii]` | 2.3843746513752824e-05 | 2.2074706956929303e-05 | 7.42% | 8.01% | 1.08x | ✅ | -| `hexbytes_getitem_index[2-palindrome numeric]` | 2.384995983697482e-05 | 2.2168935214868402e-05 | 7.05% | 7.58% | 1.08x | ✅ | -| `hexbytes_getitem_index[2-palindrome]` | 2.3353639762196912e-05 | 2.3184971391492197e-05 | 0.72% | 0.73% | 1.01x | ✅ | -| `hexbytes_getitem_index[2-repeated 0-9]` | 2.3479222769940935e-05 | 2.2220355241910037e-05 | 5.36% | 5.67% | 1.06x | ✅ | -| `hexbytes_getitem_index[2-two patterns]` | 2.3870436406362992e-05 | 2.2326472681800106e-05 | 6.47% | 6.92% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-0-9]` | 2.346875938372422e-05 | 2.240947646466136e-05 | 4.51% | 4.73% | 1.05x | ✅ | -| `hexbytes_getitem_index[3-4-byte pattern]` | 2.3721855409706934e-05 | 2.222300970933843e-05 | 6.32% | 6.74% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-all byte values]` | 2.390814788126935e-05 | 2.283953127459055e-05 | 4.47% | 4.68% | 1.05x | ✅ | -| `hexbytes_getitem_index[3-alternating 0x00/0xff]` | 2.3669588520335587e-05 | 2.2366387821447823e-05 | 5.51% | 5.83% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-alternating 0xaa/0x55]` | 2.37963607593483e-05 | 2.243596847380388e-05 | 5.72% | 6.06% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-ascii sentence]` | 2.385759012590493e-05 | 2.2598322450417e-05 | 5.28% | 5.57% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-b'\\x00'*32]` | 2.3505933187042217e-05 | 2.224940013158834e-05 | 5.35% | 5.65% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-b'\\x00\\xff\\x00\\xff']` | 2.3560394405510724e-05 | 2.2325916175874644e-05 | 5.24% | 5.53% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-b'\\x01'*100]` | 2.3743939819745725e-05 | 2.2253526385851708e-05 | 6.28% | 6.70% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-b'\\x01'*2048]` | 2.3905277881044007e-05 | 2.2377902060079857e-05 | 6.39% | 6.83% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3647841778410742e-05 | 2.2284219330703748e-05 | 5.77% | 6.12% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-b'\\x7f'*8]` | 2.3583389431878405e-05 | 2.2293803599500448e-05 | 5.47% | 5.78% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-b'\\x80'*8]` | 2.3722950242620407e-05 | 2.2286066181847813e-05 | 6.06% | 6.45% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-b'\\xde\\xad\\xbe\\xef']` | 2.3845356834118778e-05 | 2.212288604441631e-05 | 7.22% | 7.79% | 1.08x | ✅ | -| `hexbytes_getitem_index[3-b'\\xff'*64]` | 2.3719538098640988e-05 | 2.2142743590668913e-05 | 6.65% | 7.12% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-b'a'*1024]` | 2.3485133845154906e-05 | 2.2153670264862265e-05 | 5.67% | 6.01% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-long alternating]` | 2.388198217001513e-05 | 2.22183555885802e-05 | 6.97% | 7.49% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-mixed pattern]` | 2.388614646004389e-05 | 2.2712403800206335e-05 | 4.91% | 5.17% | 1.05x | ✅ | -| `hexbytes_getitem_index[3-multiples of 0x10]` | 2.387063951538705e-05 | 2.230592252192809e-05 | 6.55% | 7.01% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-palindrome ascii]` | 2.389725274772817e-05 | 2.2360159584640115e-05 | 6.43% | 6.87% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-palindrome numeric]` | 2.3798089009595062e-05 | 2.2526916278931338e-05 | 5.34% | 5.64% | 1.06x | ✅ | -| `hexbytes_getitem_index[3-palindrome]` | 2.3655942653303613e-05 | 2.213796458225677e-05 | 6.42% | 6.86% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-repeated 0-9]` | 2.396342222639396e-05 | 2.2323883357804693e-05 | 6.84% | 7.34% | 1.07x | ✅ | -| `hexbytes_getitem_index[3-two patterns]` | 2.385684287372088e-05 | 2.2693310760618144e-05 | 4.88% | 5.13% | 1.05x | ✅ | -| `hexbytes_getitem_index[4-0-9]` | 2.3899973992024223e-05 | 2.2453763928799237e-05 | 6.05% | 6.44% | 1.06x | ✅ | -| `hexbytes_getitem_index[4-4-byte pattern]` | 2.3705508776158425e-05 | 2.238011738911868e-05 | 5.59% | 5.92% | 1.06x | ✅ | -| `hexbytes_getitem_index[4-all byte values]` | 2.377875104005379e-05 | 2.22712890085195e-05 | 6.34% | 6.77% | 1.07x | ✅ | -| `hexbytes_getitem_index[4-alternating 0x00/0xff]` | 2.3802997980227825e-05 | 2.25064045339907e-05 | 5.45% | 5.76% | 1.06x | ✅ | -| `hexbytes_getitem_index[4-alternating 0xaa/0x55]` | 2.3656997750980488e-05 | 2.246474914798274e-05 | 5.04% | 5.31% | 1.05x | ✅ | -| `hexbytes_getitem_index[4-ascii sentence]` | 2.3889494842101873e-05 | 2.2232110147189814e-05 | 6.94% | 7.45% | 1.07x | ✅ | -| `hexbytes_getitem_index[4-b'\\x00'*32]` | 2.3948612391353527e-05 | 2.2580159784875707e-05 | 5.71% | 6.06% | 1.06x | ✅ | -| `hexbytes_getitem_index[4-b'\\x01'*100]` | 2.36230588877441e-05 | 2.2538682146090458e-05 | 4.59% | 4.81% | 1.05x | ✅ | -| `hexbytes_getitem_index[4-b'\\x01'*2048]` | 2.354046874295225e-05 | 2.2404037494145434e-05 | 4.83% | 5.07% | 1.05x | ✅ | -| `hexbytes_getitem_index[4-b'\\x10\\x20\\x30\\x40\\x50']` | 2.3690927947699704e-05 | 2.2461979332169837e-05 | 5.19% | 5.47% | 1.05x | ✅ | -| `hexbytes_getitem_index[4-b'\\x7f'*8]` | 2.3799501582564888e-05 | 2.225404823020082e-05 | 6.49% | 6.94% | 1.07x | ✅ | -| `hexbytes_getitem_index[4-b'\\x80'*8]` | 2.364995371200852e-05 | 2.2431861192374475e-05 | 5.15% | 5.43% | 1.05x | ✅ | -| `hexbytes_getitem_index[4-b'\\xff'*64]` | 2.3899208143721178e-05 | 2.2336480376619072e-05 | 6.54% | 7.00% | 1.07x | ✅ | -| `hexbytes_getitem_index[4-b'a'*1024]` | 2.388219329567692e-05 | 2.237994391119528e-05 | 6.29% | 6.71% | 1.07x | ✅ | -| `hexbytes_getitem_index[4-long alternating]` | 2.3825226326260514e-05 | 2.235339194559478e-05 | 6.18% | 6.58% | 1.07x | ✅ | -| `hexbytes_getitem_index[4-mixed pattern]` | 2.4263073550289538e-05 | 2.2477951042731033e-05 | 7.36% | 7.94% | 1.08x | ✅ | -| `hexbytes_getitem_index[4-multiples of 0x10]` | 2.3839900411638854e-05 | 2.2410074104850746e-05 | 6.00% | 6.38% | 1.06x | ✅ | -| `hexbytes_getitem_index[4-palindrome ascii]` | 2.413395342536019e-05 | 2.2403790136882604e-05 | 7.17% | 7.72% | 1.08x | ✅ | -| `hexbytes_getitem_index[4-palindrome numeric]` | 2.386539608948987e-05 | 2.2444926049628023e-05 | 5.95% | 6.33% | 1.06x | ✅ | -| `hexbytes_getitem_index[4-palindrome]` | 2.3624708736914828e-05 | 2.2501062408512196e-05 | 4.76% | 4.99% | 1.05x | ✅ | -| `hexbytes_getitem_index[4-repeated 0-9]` | 2.4036002099408217e-05 | 2.2293087839859523e-05 | 7.25% | 7.82% | 1.08x | ✅ | -| `hexbytes_getitem_index[4-two patterns]` | 2.377668644820311e-05 | 2.2229137838792795e-05 | 6.51% | 6.96% | 1.07x | ✅ | -| `hexbytes_getitem_index[5-0-9]` | 2.3804482853094745e-05 | 2.2123400947219126e-05 | 7.06% | 7.60% | 1.08x | ✅ | -| `hexbytes_getitem_index[5-4-byte pattern]` | 2.3919398750660017e-05 | 2.2342013515976855e-05 | 6.59% | 7.06% | 1.07x | ✅ | -| `hexbytes_getitem_index[5-all byte values]` | 2.381642502048813e-05 | 2.225679471078651e-05 | 6.55% | 7.01% | 1.07x | ✅ | -| `hexbytes_getitem_index[5-alternating 0x00/0xff]` | 2.3850033761120395e-05 | 2.242768382035353e-05 | 5.96% | 6.34% | 1.06x | ✅ | -| `hexbytes_getitem_index[5-alternating 0xaa/0x55]` | 2.3859982486855523e-05 | 2.185253475627353e-05 | 8.41% | 9.19% | 1.09x | ✅ | -| `hexbytes_getitem_index[5-ascii sentence]` | 2.3835025727299785e-05 | 2.2395683686574797e-05 | 6.04% | 6.43% | 1.06x | ✅ | -| `hexbytes_getitem_index[5-b'\\x00'*32]` | 2.3798403675411692e-05 | 2.2465672940989854e-05 | 5.60% | 5.93% | 1.06x | ✅ | -| `hexbytes_getitem_index[5-b'\\x01'*100]` | 2.3492257981176665e-05 | 2.2142185976849883e-05 | 5.75% | 6.10% | 1.06x | ✅ | -| `hexbytes_getitem_index[5-b'\\x01'*2048]` | 2.366747898620313e-05 | 2.2198146171781466e-05 | 6.21% | 6.62% | 1.07x | ✅ | -| `hexbytes_getitem_index[5-b'\\x7f'*8]` | 2.35597953145184e-05 | 2.2171523646048525e-05 | 5.89% | 6.26% | 1.06x | ✅ | -| `hexbytes_getitem_index[5-b'\\x80'*8]` | 2.3860267252043716e-05 | 2.2325881149106178e-05 | 6.43% | 6.87% | 1.07x | ✅ | -| `hexbytes_getitem_index[5-b'\\xff'*64]` | 2.38133876111381e-05 | 2.221470970606235e-05 | 6.71% | 7.20% | 1.07x | ✅ | -| `hexbytes_getitem_index[5-b'a'*1024]` | 2.387664162249834e-05 | 2.2220958262310435e-05 | 6.93% | 7.45% | 1.07x | ✅ | -| `hexbytes_getitem_index[5-long alternating]` | 2.3447450794083876e-05 | 2.2117716532324473e-05 | 5.67% | 6.01% | 1.06x | ✅ | -| `hexbytes_getitem_index[5-mixed pattern]` | 2.3858675352130537e-05 | 2.237369899823486e-05 | 6.22% | 6.64% | 1.07x | ✅ | -| `hexbytes_getitem_index[5-multiples of 0x10]` | 2.3441867659560046e-05 | 2.204999308430266e-05 | 5.94% | 6.31% | 1.06x | ✅ | -| `hexbytes_getitem_index[5-palindrome ascii]` | 2.3958043445209287e-05 | 2.2279548089798347e-05 | 7.01% | 7.53% | 1.08x | ✅ | -| `hexbytes_getitem_index[5-palindrome]` | 2.370622874194218e-05 | 2.2535518141703165e-05 | 4.94% | 5.19% | 1.05x | ✅ | -| `hexbytes_getitem_index[5-repeated 0-9]` | 2.401607357845209e-05 | 2.2335016478901267e-05 | 7.00% | 7.53% | 1.08x | ✅ | -| `hexbytes_getitem_index[5-two patterns]` | 2.384207955910319e-05 | 2.2819046333930514e-05 | 4.29% | 4.48% | 1.04x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-0-9]` | 8.068234990254468e-05 | 5.9908517862950774e-05 | 25.75% | 34.68% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-4-byte pattern]` | 8.11249058632316e-05 | 5.914985501307563e-05 | 27.09% | 37.15% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-all byte values]` | 8.09292051944004e-05 | 5.996926055642412e-05 | 25.90% | 34.95% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-alternating 0x00/0xff]` | 8.050372644893333e-05 | 5.9492500278013574e-05 | 26.10% | 35.32% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-alternating 0xaa/0x55]` | 8.160105677786958e-05 | 5.9768697206212395e-05 | 26.75% | 36.53% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-ascii sentence]` | 8.059944833324778e-05 | 6.0538737184844244e-05 | 24.89% | 33.14% | 1.33x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'']` | 7.879725653296983e-05 | 5.773333058399736e-05 | 26.73% | 36.48% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\x00'*32]` | 8.065340013430995e-05 | 5.992783206681132e-05 | 25.70% | 34.58% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\x00\\xff\\x00\\xff']` | 8.110106993329847e-05 | 6.036323340154663e-05 | 25.57% | 34.36% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01'*100]` | 8.112706850935604e-05 | 5.985948007817502e-05 | 26.22% | 35.53% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01'*2048]` | 8.147721111379799e-05 | 6.052596027497756e-05 | 25.71% | 34.62% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\x01\\x02\\x03']` | 8.167215920607164e-05 | 6.009837985140856e-05 | 26.42% | 35.90% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.114676602016646e-05 | 6.013714140361474e-05 | 25.89% | 34.94% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\x7f'*8]` | 8.158437482314103e-05 | 5.9964215072264316e-05 | 26.50% | 36.06% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\x80'*8]` | 8.11956405283511e-05 | 6.012798039697782e-05 | 25.95% | 35.04% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\xde\\xad\\xbe\\xef']` | 8.133062109897846e-05 | 6.0024769901838476e-05 | 26.20% | 35.50% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'\\xff'*64]` | 8.147021273208189e-05 | 6.014110090091815e-05 | 26.18% | 35.47% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'a'*1024]` | 8.184092645393188e-05 | 5.9690798562356445e-05 | 27.06% | 37.11% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-b'abc']` | 8.11407611580561e-05 | 6.0269786530966417e-05 | 25.72% | 34.63% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-long alternating]` | 8.138515989132823e-05 | 6.0051330791540194e-05 | 26.21% | 35.53% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-mixed pattern]` | 8.11307849411989e-05 | 5.948433203317993e-05 | 26.68% | 36.39% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-multiples of 0x10]` | 8.0865044025069e-05 | 6.067042211538623e-05 | 24.97% | 33.29% | 1.33x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-palindrome ascii]` | 8.098974116830668e-05 | 5.946342412898394e-05 | 26.58% | 36.20% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-palindrome numeric]` | 8.30720497246577e-05 | 5.996928553820368e-05 | 27.81% | 38.52% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-palindrome]` | 8.052636510236694e-05 | 6.009066007473859e-05 | 25.38% | 34.01% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-repeated 0-9]` | 8.17800832421859e-05 | 5.937056592499519e-05 | 27.40% | 37.75% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-single 0xff]` | 7.866251040166223e-05 | 5.7545369679967186e-05 | 26.85% | 36.70% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-single null byte]` | 7.89915242249266e-05 | 5.753772649427693e-05 | 27.16% | 37.29% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(-3,None)-two patterns]` | 8.080403866485248e-05 | 5.922889017319143e-05 | 26.70% | 36.43% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-0-9]` | 8.2622325636055e-05 | 6.0528968239167615e-05 | 26.74% | 36.50% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-4-byte pattern]` | 8.272651418364963e-05 | 6.092795295403125e-05 | 26.35% | 35.78% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-all byte values]` | 8.255031829407812e-05 | 6.0791886106560145e-05 | 26.36% | 35.79% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-alternating 0x00/0xff]` | 8.21723996281765e-05 | 6.0797497703534535e-05 | 26.01% | 35.16% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-alternating 0xaa/0x55]` | 8.221975981903979e-05 | 6.072751465186438e-05 | 26.14% | 35.39% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-ascii sentence]` | 8.367206394174686e-05 | 6.133230997235685e-05 | 26.70% | 36.42% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'']` | 8.06918569884131e-05 | 5.772912687932482e-05 | 28.46% | 39.78% | 1.40x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\x00'*32]` | 8.266038445917815e-05 | 6.0560119980356125e-05 | 26.74% | 36.49% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\x00\\xff\\x00\\xff']` | 8.20339136045329e-05 | 6.0075424777740126e-05 | 26.77% | 36.55% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\x01'*100]` | 8.217707354153222e-05 | 6.054433994945807e-05 | 26.32% | 35.73% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\x01'*2048]` | 8.258134725819903e-05 | 6.037501951340134e-05 | 26.89% | 36.78% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\x01\\x02\\x03']` | 8.256973994855508e-05 | 6.028594637574512e-05 | 26.99% | 36.96% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.248224031876366e-05 | 6.0332711841273715e-05 | 26.85% | 36.71% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\x7f'*8]` | 8.179846849894452e-05 | 6.092441941098647e-05 | 25.52% | 34.26% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\x80'*8]` | 8.186628293610639e-05 | 6.0235752841171e-05 | 26.42% | 35.91% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\xde\\xad\\xbe\\xef']` | 8.092846841651972e-05 | 6.04425395196323e-05 | 25.31% | 33.89% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'\\xff'*64]` | 8.124670067572987e-05 | 6.041566846002542e-05 | 25.64% | 34.48% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'a'*1024]` | 8.175597454964947e-05 | 6.06864513192614e-05 | 25.77% | 34.72% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-b'abc']` | 8.198075665936462e-05 | 6.0627726194316385e-05 | 26.05% | 35.22% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-long alternating]` | 8.204332835156302e-05 | 6.07988550706465e-05 | 25.89% | 34.94% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-mixed pattern]` | 8.17248904408768e-05 | 6.108961798914236e-05 | 25.25% | 33.78% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-multiples of 0x10]` | 8.291109128917191e-05 | 6.126453753386428e-05 | 26.11% | 35.33% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-palindrome ascii]` | 8.302702215551893e-05 | 6.0712845747646644e-05 | 26.88% | 36.75% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-palindrome numeric]` | 8.24454859497045e-05 | 6.0612859259637294e-05 | 26.48% | 36.02% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-palindrome]` | 8.080784793291502e-05 | 6.0116598701386324e-05 | 25.61% | 34.42% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-repeated 0-9]` | 8.334414217224779e-05 | 5.999776415961464e-05 | 28.01% | 38.91% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-single 0xff]` | 8.156183284693949e-05 | 5.931348806830272e-05 | 27.28% | 37.51% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-single null byte]` | 8.174356108905515e-05 | 5.900020044260341e-05 | 27.82% | 38.55% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(0,3)-two patterns]` | 8.22219209418392e-05 | 6.084418406394616e-05 | 26.00% | 35.14% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-0-9]` | 8.313658701170756e-05 | 5.895483225067839e-05 | 29.09% | 41.02% | 1.41x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-4-byte pattern]` | 8.196193234840055e-05 | 5.9606213484058697e-05 | 27.28% | 37.51% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-all byte values]` | 8.346399715113727e-05 | 6.023051273376708e-05 | 27.84% | 38.57% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-alternating 0x00/0xff]` | 8.179198156866263e-05 | 6.016420690452284e-05 | 26.44% | 35.95% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-alternating 0xaa/0x55]` | 8.163817929710001e-05 | 5.9934526712899444e-05 | 26.59% | 36.21% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-ascii sentence]` | 8.209272865155255e-05 | 6.092703580256333e-05 | 25.78% | 34.74% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'']` | 8.027790615778153e-05 | 5.7995641927442527e-05 | 27.76% | 38.42% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\x00'*32]` | 8.276872109450775e-05 | 6.056089253842826e-05 | 26.83% | 36.67% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\x00\\xff\\x00\\xff']` | 8.19567980550223e-05 | 5.9205196348911915e-05 | 27.76% | 38.43% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\x01'*100]` | 8.313834030044157e-05 | 6.092565019477837e-05 | 26.72% | 36.46% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\x01'*2048]` | 8.246281656146155e-05 | 5.975929586280049e-05 | 27.53% | 37.99% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\x01\\x02\\x03']` | 8.199072701858649e-05 | 5.940088034279834e-05 | 27.55% | 38.03% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.258274406057332e-05 | 6.110407110891471e-05 | 26.01% | 35.15% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\x7f'*8]` | 8.206723002467621e-05 | 6.056757308507195e-05 | 26.20% | 35.50% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\x80'*8]` | 8.208912763807277e-05 | 6.06431315458422e-05 | 26.13% | 35.36% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\xde\\xad\\xbe\\xef']` | 8.281438339446592e-05 | 5.9749517630166066e-05 | 27.85% | 38.60% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'\\xff'*64]` | 8.281844606293529e-05 | 5.9608617469888645e-05 | 28.02% | 38.94% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'a'*1024]` | 8.233301537469728e-05 | 5.9421223063502564e-05 | 27.83% | 38.56% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-b'abc']` | 8.317798982465156e-05 | 6.0510199715760295e-05 | 27.25% | 37.46% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-long alternating]` | 8.177884355440976e-05 | 5.960249797801825e-05 | 27.12% | 37.21% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-mixed pattern]` | 8.153793358950345e-05 | 6.058071977552699e-05 | 25.70% | 34.59% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-multiples of 0x10]` | 8.248096552844894e-05 | 5.9685025348125585e-05 | 27.64% | 38.19% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-palindrome ascii]` | 8.139138326813279e-05 | 6.119322011840429e-05 | 24.82% | 33.01% | 1.33x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-palindrome numeric]` | 8.14961322142407e-05 | 6.135827801269117e-05 | 24.71% | 32.82% | 1.33x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-palindrome]` | 8.155820494943751e-05 | 6.018801583839876e-05 | 26.20% | 35.51% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-repeated 0-9]` | 8.264213345195723e-05 | 6.0417248049566416e-05 | 26.89% | 36.79% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-single 0xff]` | 8.023151070244493e-05 | 5.7594480021759474e-05 | 28.21% | 39.30% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-single null byte]` | 8.018753225122147e-05 | 5.765371340802396e-05 | 28.10% | 39.08% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(1,6)-two patterns]` | 8.131570729214625e-05 | 6.049279725871943e-05 | 25.61% | 34.42% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-0-9]` | 8.14121963052695e-05 | 6.018746420393172e-05 | 26.07% | 35.26% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-4-byte pattern]` | 8.240409685413533e-05 | 6.081408245115794e-05 | 26.20% | 35.50% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-all byte values]` | 8.202717933675196e-05 | 6.065021454450571e-05 | 26.06% | 35.25% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-alternating 0x00/0xff]` | 8.2030339885261e-05 | 6.0688604341073643e-05 | 26.02% | 35.17% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-alternating 0xaa/0x55]` | 8.191594718237171e-05 | 6.068378042598657e-05 | 25.92% | 34.99% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-ascii sentence]` | 8.218106248410972e-05 | 6.071176547484893e-05 | 26.12% | 35.36% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'']` | 7.846717309544713e-05 | 5.731748541262407e-05 | 26.95% | 36.90% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\x00'*32]` | 8.171215331135617e-05 | 6.049818370995403e-05 | 25.96% | 35.07% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\x00\\xff\\x00\\xff']` | 8.008490774949858e-05 | 6.003003665949191e-05 | 25.04% | 33.41% | 1.33x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\x01'*100]` | 8.170876382529361e-05 | 6.096559520721099e-05 | 25.39% | 34.02% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\x01'*2048]` | 0.00010476437791326655 | 7.746346799212244e-05 | 26.06% | 35.24% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\x01\\x02\\x03']` | 7.960454609000436e-05 | 5.7623088750788484e-05 | 27.61% | 38.15% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 8.107940673613911e-05 | 6.017446222218925e-05 | 25.78% | 34.74% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\x7f'*8]` | 8.179921890396522e-05 | 6.0127637423181724e-05 | 26.49% | 36.04% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\x80'*8]` | 8.094503061559896e-05 | 6.033906979829822e-05 | 25.46% | 34.15% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\xde\\xad\\xbe\\xef']` | 8.2657600133284e-05 | 6.065080339822555e-05 | 26.62% | 36.28% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'\\xff'*64]` | 8.194716225175662e-05 | 6.017795967458637e-05 | 26.56% | 36.17% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'a'*1024]` | 9.693064215296854e-05 | 7.569989005474179e-05 | 21.90% | 28.05% | 1.28x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-b'abc']` | 7.912194866352589e-05 | 5.7795536500223504e-05 | 26.95% | 36.90% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-long alternating]` | 0.00010049567496632814 | 7.225055857475158e-05 | 28.11% | 39.09% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-mixed pattern]` | 8.21531364470839e-05 | 6.0966463356750096e-05 | 25.79% | 34.75% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-multiples of 0x10]` | 8.182128273575786e-05 | 5.950911816715105e-05 | 27.27% | 37.49% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-palindrome ascii]` | 8.173102597293032e-05 | 6.0450363378619016e-05 | 26.04% | 35.20% | 1.35x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-palindrome numeric]` | 8.064481667943535e-05 | 6.005529660558877e-05 | 25.53% | 34.28% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-palindrome]` | 8.146838256348088e-05 | 5.930252168165231e-05 | 27.21% | 37.38% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-repeated 0-9]` | 8.158039589364289e-05 | 6.068757436283316e-05 | 25.61% | 34.43% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-single 0xff]` | 7.892234626219822e-05 | 5.709236282816077e-05 | 27.66% | 38.24% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-single null byte]` | 7.835202393129527e-05 | 5.734935938542202e-05 | 26.81% | 36.62% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(2,None)-two patterns]` | 8.124228911371968e-05 | 6.0960659161912064e-05 | 24.96% | 33.27% | 1.33x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-0-9]` | 7.9430356937195e-05 | 5.75138086086997e-05 | 27.59% | 38.11% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-4-byte pattern]` | 8.083538128638625e-05 | 5.862082945179073e-05 | 27.48% | 37.90% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-all byte values]` | 8.060951725703728e-05 | 5.933151936678779e-05 | 26.40% | 35.86% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-alternating 0x00/0xff]` | 7.999629243724944e-05 | 5.763557713639643e-05 | 27.95% | 38.80% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-alternating 0xaa/0x55]` | 8.02130539314506e-05 | 5.7282829826576e-05 | 28.59% | 40.03% | 1.40x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-ascii sentence]` | 8.022463458559608e-05 | 5.9020510442109744e-05 | 26.43% | 35.93% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'']` | 7.71061669046454e-05 | 5.565648922236641e-05 | 27.82% | 38.54% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\x00'*32]` | 8.090211399786762e-05 | 5.926002974818658e-05 | 26.75% | 36.52% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\x00\\xff\\x00\\xff']` | 8.099782549973611e-05 | 5.8727517655832474e-05 | 27.49% | 37.92% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\x01'*100]` | 8.115939604376683e-05 | 5.710263988029543e-05 | 29.64% | 42.13% | 1.42x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\x01'*2048]` | 0.00010146242689006956 | 7.806360940270111e-05 | 23.06% | 29.97% | 1.30x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\x01\\x02\\x03']` | 8.020230350063798e-05 | 5.804965471422574e-05 | 27.62% | 38.16% | 1.38x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\x10\\x20\\x30\\x40\\x50']` | 7.97868648430571e-05 | 5.6351813911057925e-05 | 29.37% | 41.59% | 1.42x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\x7f'*8]` | 7.975691366162501e-05 | 5.600672332160979e-05 | 29.78% | 42.41% | 1.42x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\x80'*8]` | 7.945457643561741e-05 | 5.638943533155044e-05 | 29.03% | 40.90% | 1.41x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\xde\\xad\\xbe\\xef']` | 7.999624765962864e-05 | 5.88580201326653e-05 | 26.42% | 35.91% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'\\xff'*64]` | 8.017778856891062e-05 | 5.9135237732123635e-05 | 26.24% | 35.58% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'a'*1024]` | 9.863015309092291e-05 | 6.957885123547411e-05 | 29.45% | 41.75% | 1.42x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-b'abc']` | 8.043158298894438e-05 | 5.794496088357798e-05 | 27.96% | 38.81% | 1.39x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-long alternating]` | 9.52467992574056e-05 | 7.340333486803448e-05 | 22.93% | 29.76% | 1.30x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-mixed pattern]` | 8.073709406148429e-05 | 5.952576523301626e-05 | 26.27% | 35.63% | 1.36x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-multiples of 0x10]` | 7.976009010096381e-05 | 5.6305954230380405e-05 | 29.41% | 41.65% | 1.42x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-palindrome ascii]` | 7.920245338866143e-05 | 5.763644401517949e-05 | 27.23% | 37.42% | 1.37x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-palindrome numeric]` | 7.9939929537322e-05 | 5.7125410998791315e-05 | 28.54% | 39.94% | 1.40x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-palindrome]` | 8.016544171041521e-05 | 5.551693119839742e-05 | 30.75% | 44.40% | 1.44x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-repeated 0-9]` | 8.068510058369967e-05 | 6.0166740150958995e-05 | 25.43% | 34.10% | 1.34x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-single 0xff]` | 7.804954601624467e-05 | 5.506197227846088e-05 | 29.45% | 41.75% | 1.42x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-single null byte]` | 7.816215323890064e-05 | 5.5627027377838706e-05 | 28.83% | 40.51% | 1.41x | ✅ | -| `hexbytes_getitem_slice[slice(None,None)-two patterns]` | 8.071645942788979e-05 | 5.934724027483824e-05 | 26.47% | 36.01% | 1.36x | ✅ | -| `hexbytes_new['']` | 7.059339453681849e-05 | 3.720572167745306e-05 | 47.30% | 89.74% | 1.90x | ✅ | -| `hexbytes_new['0x'+'00'*64]` | 9.185311650414212e-05 | 4.9458678953195796e-05 | 46.15% | 85.72% | 1.86x | ✅ | -| `hexbytes_new['0x'+'a'*128]` | 9.184894177237468e-05 | 5.104373326869315e-05 | 44.43% | 79.94% | 1.80x | ✅ | -| `hexbytes_new['0x'+'ff'*32]` | 8.88221703346839e-05 | 4.645459160491125e-05 | 47.70% | 91.20% | 1.91x | ✅ | -| `hexbytes_new['0x']` | 7.839122044398893e-05 | 3.842018705163114e-05 | 50.99% | 104.04% | 2.04x | ✅ | -| `hexbytes_new['0x1234']` | 8.604767258883253e-05 | 4.458978211603869e-05 | 48.18% | 92.98% | 1.93x | ✅ | -| `hexbytes_new['0xCAFEBABE']` | 8.569109342851317e-05 | 4.365468820511476e-05 | 49.06% | 96.29% | 1.96x | ✅ | -| `hexbytes_new['0xabcdef']` | 8.593088756520804e-05 | 4.45373277594925e-05 | 48.17% | 92.94% | 1.93x | ✅ | -| `hexbytes_new['0xdeadbeef']` | 8.627125497488135e-05 | 4.442037623583596e-05 | 48.51% | 94.22% | 1.94x | ✅ | -| `hexbytes_new['abc']` | 8.213154539849242e-05 | 4.7106935923321183e-05 | 42.64% | 74.35% | 1.74x | ✅ | -| `hexbytes_new['deadbeef']` | 7.619061738594097e-05 | 4.1301610026598785e-05 | 45.79% | 84.47% | 1.84x | ✅ | -| `hexbytes_new[0-9]` | 4.295882153627664e-05 | 2.5316265129541266e-05 | 41.07% | 69.69% | 1.70x | ✅ | -| `hexbytes_new[0]` | 0.00012231687726766509 | 6.0478503253778025e-05 | 50.56% | 102.25% | 2.02x | ✅ | -| `hexbytes_new[123456]` | 0.0001266123322099141 | 6.583570512732421e-05 | 48.00% | 92.32% | 1.92x | ✅ | -| `hexbytes_new[2**16]` | 0.00012774508225165453 | 6.617318450917904e-05 | 48.20% | 93.05% | 1.93x | ✅ | -| `hexbytes_new[2**256-1]` | 0.00013121266143061903 | 7.351050389468393e-05 | 43.98% | 78.50% | 1.78x | ✅ | -| `hexbytes_new[2**32]` | 0.00013085130021646147 | 6.981460054531131e-05 | 46.65% | 87.43% | 1.87x | ✅ | -| `hexbytes_new[2**64]` | 0.0001324229245798965 | 7.127814146942154e-05 | 46.17% | 85.78% | 1.86x | ✅ | -| `hexbytes_new[2**8]` | 0.00012605911740696366 | 6.3048691085867e-05 | 49.98% | 99.94% | 2.00x | ✅ | -| `hexbytes_new[4-byte pattern]` | 4.295112867205666e-05 | 2.7806419556598662e-05 | 35.26% | 54.46% | 1.54x | ✅ | -| `hexbytes_new[False]` | 6.087290743084603e-05 | 2.6771864289568586e-05 | 56.02% | 127.38% | 2.27x | ✅ | -| `hexbytes_new[True]` | 6.088600700348238e-05 | 2.696853017901539e-05 | 55.71% | 125.77% | 2.26x | ✅ | -| `hexbytes_new[all byte values]` | 4.333466030390133e-05 | 2.7894081810705685e-05 | 35.63% | 55.35% | 1.55x | ✅ | -| `hexbytes_new[alternating 0x00/0xff]` | 4.287333638228319e-05 | 2.594063403652535e-05 | 39.49% | 65.27% | 1.65x | ✅ | -| `hexbytes_new[alternating 0xaa/0x55]` | 4.273885980923265e-05 | 2.5827765223145366e-05 | 39.57% | 65.48% | 1.65x | ✅ | -| `hexbytes_new[ascii sentence]` | 4.313410983817353e-05 | 2.546554532135807e-05 | 40.96% | 69.38% | 1.69x | ✅ | -| `hexbytes_new[b'']` | 4.1701536417217834e-05 | 2.5443427864218587e-05 | 38.99% | 63.90% | 1.64x | ✅ | -| `hexbytes_new[b'\\x00'*32]` | 4.2708400224018625e-05 | 2.531691282877622e-05 | 40.72% | 68.70% | 1.69x | ✅ | -| `hexbytes_new[b'\\x00\\xff\\x00\\xff']` | 4.2081834338195306e-05 | 2.5464436144364045e-05 | 39.49% | 65.26% | 1.65x | ✅ | -| `hexbytes_new[b'\\x01'*100]` | 4.387343088107201e-05 | 2.6034466974391452e-05 | 40.66% | 68.52% | 1.69x | ✅ | -| `hexbytes_new[b'\\x01'*2048]` | 5.733198446675121e-05 | 3.879941616922359e-05 | 32.33% | 47.77% | 1.48x | ✅ | -| `hexbytes_new[b'\\x01\\x02\\x03']` | 4.2723619263841565e-05 | 2.5355395989687225e-05 | 40.65% | 68.50% | 1.68x | ✅ | -| `hexbytes_new[b'\\x10\\x20\\x30\\x40\\x50']` | 4.224746088317716e-05 | 2.528448930199794e-05 | 40.15% | 67.09% | 1.67x | ✅ | -| `hexbytes_new[b'\\x7f'*8]` | 4.213323056509161e-05 | 2.4986245013606142e-05 | 40.70% | 68.63% | 1.69x | ✅ | -| `hexbytes_new[b'\\x80'*8]` | 4.2536395501683135e-05 | 2.5072862766728953e-05 | 41.06% | 69.65% | 1.70x | ✅ | -| `hexbytes_new[b'\\xde\\xad\\xbe\\xef']` | 4.2394029725542104e-05 | 2.540955404834232e-05 | 40.06% | 66.84% | 1.67x | ✅ | -| `hexbytes_new[b'\\xff'*64]` | 4.261945097059883e-05 | 2.587775309265785e-05 | 39.28% | 64.70% | 1.65x | ✅ | -| `hexbytes_new[b'a'*1024]` | 5.133675556752819e-05 | 3.3138708548557765e-05 | 35.45% | 54.91% | 1.55x | ✅ | -| `hexbytes_new[b'abc']` | 4.2674347397571076e-05 | 2.5163975539327663e-05 | 41.03% | 69.59% | 1.70x | ✅ | -| `hexbytes_new[bytearray(0-9)]` | 6.865169676977511e-05 | 3.7259202139075596e-05 | 45.73% | 84.25% | 1.84x | ✅ | -| `hexbytes_new[bytearray(4-byte pattern)]` | 6.953209316813137e-05 | 3.816708106647471e-05 | 45.11% | 82.18% | 1.82x | ✅ | -| `hexbytes_new[bytearray(all byte values)]` | 6.898457893830663e-05 | 3.8168352788462077e-05 | 44.67% | 80.74% | 1.81x | ✅ | -| `hexbytes_new[bytearray(alternating 0x00/0xff)]` | 6.908631410366376e-05 | 3.778673334190037e-05 | 45.31% | 82.83% | 1.83x | ✅ | -| `hexbytes_new[bytearray(alternating 0xaa/0x55)]` | 6.845419039658357e-05 | 3.777392923671646e-05 | 44.82% | 81.22% | 1.81x | ✅ | -| `hexbytes_new[bytearray(ascii sentence)]` | 6.972701953861159e-05 | 3.732977678561211e-05 | 46.46% | 86.79% | 1.87x | ✅ | -| `hexbytes_new[bytearray(b'')]` | 6.678502978133552e-05 | 3.561588238570766e-05 | 46.67% | 87.51% | 1.88x | ✅ | -| `hexbytes_new[bytearray(b'\\x00'*32)]` | 6.932840331862772e-05 | 3.722964287143302e-05 | 46.30% | 86.22% | 1.86x | ✅ | -| `hexbytes_new[bytearray(b'\\x00\\xff\\x00\\xff')]` | 6.955368340544366e-05 | 4.051862445406872e-05 | 41.74% | 71.66% | 1.72x | ✅ | -| `hexbytes_new[bytearray(b'\\x01'*100)]` | 6.929357571310845e-05 | 3.8765838753758206e-05 | 44.06% | 78.75% | 1.79x | ✅ | -| `hexbytes_new[bytearray(b'\\x01'*2048)]` | 9.350162891314769e-05 | 5.560644346862349e-05 | 40.53% | 68.15% | 1.68x | ✅ | -| `hexbytes_new[bytearray(b'\\x01\\x02\\x03')]` | 6.935026736671355e-05 | 3.845283974606172e-05 | 44.55% | 80.35% | 1.80x | ✅ | -| `hexbytes_new[bytearray(b'\\x10\\x20\\x30\\x40\\x50')]` | 6.868295439875171e-05 | 3.880361048641301e-05 | 43.50% | 77.00% | 1.77x | ✅ | -| `hexbytes_new[bytearray(b'\\x7f'*8)]` | 6.8469512349617e-05 | 3.72148175217809e-05 | 45.65% | 83.98% | 1.84x | ✅ | -| `hexbytes_new[bytearray(b'\\x80'*8)]` | 6.842226934820798e-05 | 3.7711169514167804e-05 | 44.88% | 81.44% | 1.81x | ✅ | -| `hexbytes_new[bytearray(b'\\xde\\xad\\xbe\\xef')]` | 6.90195149679681e-05 | 3.838316011293737e-05 | 44.39% | 79.82% | 1.80x | ✅ | -| `hexbytes_new[bytearray(b'\\xff'*64)]` | 6.919485734372232e-05 | 3.7846437835231215e-05 | 45.30% | 82.83% | 1.83x | ✅ | -| `hexbytes_new[bytearray(b'a'*1024)]` | 8.567915298868023e-05 | 5.015077982644348e-05 | 41.47% | 70.84% | 1.71x | ✅ | -| `hexbytes_new[bytearray(b'abc')]` | 6.9138375339417e-05 | 3.831013846730171e-05 | 44.59% | 80.47% | 1.80x | ✅ | -| `hexbytes_new[bytearray(long alternating)]` | 8.756419426149756e-05 | 4.940683158110184e-05 | 43.58% | 77.23% | 1.77x | ✅ | -| `hexbytes_new[bytearray(mixed pattern)]` | 6.93203185786192e-05 | 3.906978385134366e-05 | 43.64% | 77.43% | 1.77x | ✅ | -| `hexbytes_new[bytearray(multiples of 0x10)]` | 6.887247167193475e-05 | 3.7106534309345784e-05 | 46.12% | 85.61% | 1.86x | ✅ | -| `hexbytes_new[bytearray(palindrome ascii)]` | 6.746962549895354e-05 | 3.7175894460748066e-05 | 44.90% | 81.49% | 1.81x | ✅ | -| `hexbytes_new[bytearray(palindrome numeric)]` | 6.869543028529821e-05 | 3.81874595499812e-05 | 44.41% | 79.89% | 1.80x | ✅ | -| `hexbytes_new[bytearray(palindrome)]` | 6.868747138894986e-05 | 3.733346010256775e-05 | 45.65% | 83.98% | 1.84x | ✅ | -| `hexbytes_new[bytearray(repeated 0-9)]` | 6.911508148086022e-05 | 3.761974277890361e-05 | 45.57% | 83.72% | 1.84x | ✅ | -| `hexbytes_new[bytearray(single 0xff)]` | 6.969344641567276e-05 | 3.821283515052185e-05 | 45.17% | 82.38% | 1.82x | ✅ | -| `hexbytes_new[bytearray(single null byte)]` | 6.8821272252622e-05 | 3.81009238681271e-05 | 44.64% | 80.63% | 1.81x | ✅ | -| `hexbytes_new[bytearray(two patterns)]` | 6.947249127955981e-05 | 3.830322091851254e-05 | 44.87% | 81.38% | 1.81x | ✅ | -| `hexbytes_new[long alternating]` | 5.160353372444581e-05 | 3.319370597996107e-05 | 35.68% | 55.46% | 1.55x | ✅ | -| `hexbytes_new[memoryview(0-9)]` | 8.402488421221348e-05 | 4.305165841161287e-05 | 48.76% | 95.17% | 1.95x | ✅ | -| `hexbytes_new[memoryview(4-byte pattern)]` | 8.483368913519236e-05 | 4.420043890266264e-05 | 47.90% | 91.93% | 1.92x | ✅ | -| `hexbytes_new[memoryview(all byte values)]` | 8.277553206819768e-05 | 4.437347169215945e-05 | 46.39% | 86.54% | 1.87x | ✅ | -| `hexbytes_new[memoryview(alternating 0x00/0xff)]` | 8.432842735782323e-05 | 4.3162543582832885e-05 | 48.82% | 95.37% | 1.95x | ✅ | -| `hexbytes_new[memoryview(alternating 0xaa/0x55)]` | 8.4226051455622e-05 | 4.2706406710533925e-05 | 49.30% | 97.22% | 1.97x | ✅ | -| `hexbytes_new[memoryview(ascii sentence)]` | 8.28974079227692e-05 | 4.2487380181126084e-05 | 48.75% | 95.11% | 1.95x | ✅ | -| `hexbytes_new[memoryview(b'')]` | 8.23962123283304e-05 | 4.025397220300485e-05 | 51.15% | 104.69% | 2.05x | ✅ | -| `hexbytes_new[memoryview(b'\\x00'*32)]` | 8.302596758787724e-05 | 4.27510432520547e-05 | 48.51% | 94.21% | 1.94x | ✅ | -| `hexbytes_new[memoryview(b'\\x00\\xff\\x00\\xff')]` | 8.356703476862896e-05 | 4.305663606365146e-05 | 48.48% | 94.09% | 1.94x | ✅ | -| `hexbytes_new[memoryview(b'\\x01'*100)]` | 8.392830503024734e-05 | 4.306008859209643e-05 | 48.69% | 94.91% | 1.95x | ✅ | -| `hexbytes_new[memoryview(b'\\x01'*2048)]` | 0.0001083133241625787 | 6.181063451514009e-05 | 42.93% | 75.23% | 1.75x | ✅ | -| `hexbytes_new[memoryview(b'\\x01\\x02\\x03')]` | 8.274879907228332e-05 | 4.235713144033117e-05 | 48.81% | 95.36% | 1.95x | ✅ | -| `hexbytes_new[memoryview(b'\\x10\\x20\\x30\\x40\\x50')]` | 8.341332207145342e-05 | 4.2522852834659024e-05 | 49.02% | 96.16% | 1.96x | ✅ | -| `hexbytes_new[memoryview(b'\\x7f'*8)]` | 8.277404148909936e-05 | 4.275480455433159e-05 | 48.35% | 93.60% | 1.94x | ✅ | -| `hexbytes_new[memoryview(b'\\x80'*8)]` | 8.32985845173698e-05 | 4.2725686219471154e-05 | 48.71% | 94.96% | 1.95x | ✅ | -| `hexbytes_new[memoryview(b'\\xde\\xad\\xbe\\xef')]` | 8.34094967409787e-05 | 4.253482172593846e-05 | 49.00% | 96.10% | 1.96x | ✅ | -| `hexbytes_new[memoryview(b'\\xff'*64)]` | 8.333514805646204e-05 | 4.2686659313615054e-05 | 48.78% | 95.23% | 1.95x | ✅ | -| `hexbytes_new[memoryview(b'a'*1024)]` | 9.924937529033548e-05 | 5.5952107027414155e-05 | 43.62% | 77.38% | 1.77x | ✅ | -| `hexbytes_new[memoryview(b'abc')]` | 8.35927274669656e-05 | 4.261450935855843e-05 | 49.02% | 96.16% | 1.96x | ✅ | -| `hexbytes_new[memoryview(long alternating)]` | 0.00010227541168152174 | 5.6218582273413e-05 | 45.03% | 81.92% | 1.82x | ✅ | -| `hexbytes_new[memoryview(mixed pattern)]` | 8.042701159791098e-05 | 4.298920272923132e-05 | 46.55% | 87.09% | 1.87x | ✅ | -| `hexbytes_new[memoryview(multiples of 0x10)]` | 8.40677904662531e-05 | 4.314210112540732e-05 | 48.68% | 94.86% | 1.95x | ✅ | -| `hexbytes_new[memoryview(palindrome ascii)]` | 8.324889707805461e-05 | 4.310495465835889e-05 | 48.22% | 93.13% | 1.93x | ✅ | -| `hexbytes_new[memoryview(palindrome numeric)]` | 8.343425922642345e-05 | 4.273448915555574e-05 | 48.78% | 95.24% | 1.95x | ✅ | -| `hexbytes_new[memoryview(palindrome)]` | 8.561975046176595e-05 | 4.265896393780081e-05 | 50.18% | 100.71% | 2.01x | ✅ | -| `hexbytes_new[memoryview(repeated 0-9)]` | 8.310467831977971e-05 | 4.3063931759602075e-05 | 48.18% | 92.98% | 1.93x | ✅ | -| `hexbytes_new[memoryview(single 0xff)]` | 8.320841623582506e-05 | 4.2339979937306514e-05 | 49.12% | 96.52% | 1.97x | ✅ | -| `hexbytes_new[memoryview(single null byte)]` | 8.366610652141289e-05 | 4.24293937974122e-05 | 49.29% | 97.19% | 1.97x | ✅ | -| `hexbytes_new[memoryview(two patterns)]` | 8.162854716979587e-05 | 4.3148312062757567e-05 | 47.14% | 89.18% | 1.89x | ✅ | -| `hexbytes_new[mixed pattern]` | 4.3233341128517325e-05 | 2.5983755841529144e-05 | 39.90% | 66.39% | 1.66x | ✅ | -| `hexbytes_new[multiples of 0x10]` | 4.453038188270421e-05 | 2.5264566840342406e-05 | 43.26% | 76.26% | 1.76x | ✅ | -| `hexbytes_new[palindrome ascii]` | 4.229629357318056e-05 | 2.5336603703738986e-05 | 40.10% | 66.94% | 1.67x | ✅ | -| `hexbytes_new[palindrome numeric]` | 4.272307948255706e-05 | 2.5146011528992055e-05 | 41.14% | 69.90% | 1.70x | ✅ | -| `hexbytes_new[palindrome]` | 4.201348902376135e-05 | 2.5233103985190362e-05 | 39.94% | 66.50% | 1.67x | ✅ | -| `hexbytes_new[repeated 0-9]` | 4.2849040366098236e-05 | 2.5941053878904493e-05 | 39.46% | 65.18% | 1.65x | ✅ | -| `hexbytes_new[single 0xff]` | 4.286213200795317e-05 | 2.492020956546657e-05 | 41.86% | 72.00% | 1.72x | ✅ | -| `hexbytes_new[single null byte]` | 4.192499090325599e-05 | 2.499780743653151e-05 | 40.37% | 67.71% | 1.68x | ✅ | -| `hexbytes_new[two patterns]` | 4.263737600661353e-05 | 2.5978849285802113e-05 | 39.07% | 64.12% | 1.64x | ✅ | -| `hexbytes_repr[0-9]` | 2.8906603901256988e-05 | 4.826409864705047e-05 | -66.97% | -40.11% | 0.60x | ❌ | -| `hexbytes_repr[4-byte pattern]` | 0.00011963341642583751 | 0.0001400665401070896 | -17.08% | -14.59% | 0.85x | ❌ | -| `hexbytes_repr[all byte values]` | 0.00011982235283705905 | 0.00013990902582604605 | -16.76% | -14.36% | 0.86x | ❌ | -| `hexbytes_repr[alternating 0x00/0xff]` | 4.856278231022973e-05 | 6.823805107868716e-05 | -40.52% | -28.83% | 0.71x | ❌ | -| `hexbytes_repr[alternating 0xaa/0x55]` | 4.857590398733753e-05 | 6.995288404312158e-05 | -44.01% | -30.56% | 0.69x | ❌ | -| `hexbytes_repr[ascii sentence]` | 4.031931849084338e-05 | 5.950601363909072e-05 | -47.59% | -32.24% | 0.68x | ❌ | -| `hexbytes_repr[b'']` | 2.1317235451217533e-05 | 3.9220457560879214e-05 | -83.98% | -45.65% | 0.54x | ❌ | -| `hexbytes_repr[b'\\x00'*32]` | 3.6531415565533604e-05 | 5.550275792589815e-05 | -51.93% | -34.18% | 0.66x | ❌ | -| `hexbytes_repr[b'\\x00\\xff\\x00\\xff']` | 2.637317037783945e-05 | 4.5718566832638076e-05 | -73.35% | -42.31% | 0.58x | ❌ | -| `hexbytes_repr[b'\\x01'*100]` | 6.088965111409175e-05 | 8.061184262466249e-05 | -32.39% | -24.47% | 0.76x | ❌ | -| `hexbytes_repr[b'\\x01'*2048]` | 0.0007614258905273656 | 0.0007861038751990369 | -3.24% | -3.14% | 0.97x | ❌ | -| `hexbytes_repr[b'\\x01\\x02\\x03']` | 2.6209223833763088e-05 | 4.54939655277082e-05 | -73.58% | -42.39% | 0.58x | ❌ | -| `hexbytes_repr[b'\\x10\\x20\\x30\\x40\\x50']` | 2.7028655231277712e-05 | 4.619027613384838e-05 | -70.89% | -41.48% | 0.59x | ❌ | -| `hexbytes_repr[b'\\x7f'*8]` | 2.8230645154587657e-05 | 4.904206182181031e-05 | -73.72% | -42.44% | 0.58x | ❌ | -| `hexbytes_repr[b'\\x80'*8]` | 2.8426131680960446e-05 | 4.777460813929573e-05 | -68.07% | -40.50% | 0.60x | ❌ | -| `hexbytes_repr[b'\\xde\\xad\\xbe\\xef']` | 2.6337729088802863e-05 | 4.547637607019854e-05 | -72.67% | -42.08% | 0.58x | ❌ | -| `hexbytes_repr[b'\\xff'*64]` | 4.864470126407969e-05 | 6.820290034013081e-05 | -40.21% | -28.68% | 0.71x | ❌ | -| `hexbytes_repr[b'a'*1024]` | 0.0003943152236865464 | 0.0004167634849109744 | -5.69% | -5.39% | 0.95x | ❌ | -| `hexbytes_repr[b'abc']` | 2.6066297462518963e-05 | 4.519746535806044e-05 | -73.39% | -42.33% | 0.58x | ❌ | -| `hexbytes_repr[long alternating]` | 0.00039789659825941614 | 0.00041966943296914243 | -5.47% | -5.19% | 0.95x | ❌ | -| `hexbytes_repr[mixed pattern]` | 9.750328166691435e-05 | 0.00011687490478363051 | -19.87% | -16.57% | 0.83x | ❌ | -| `hexbytes_repr[multiples of 0x10]` | 2.8799433607726066e-05 | 4.825756547722914e-05 | -67.56% | -40.32% | 0.60x | ❌ | -| `hexbytes_repr[palindrome ascii]` | 2.7796805953080366e-05 | 4.6697563483038906e-05 | -68.00% | -40.47% | 0.60x | ❌ | -| `hexbytes_repr[palindrome numeric]` | 2.7060029458088667e-05 | 4.60052916156726e-05 | -70.01% | -41.18% | 0.59x | ❌ | -| `hexbytes_repr[palindrome]` | 3.1699440174901834e-05 | 5.113128257544771e-05 | -61.30% | -38.00% | 0.62x | ❌ | -| `hexbytes_repr[repeated 0-9]` | 6.1059735802075e-05 | 8.09308274489489e-05 | -32.54% | -24.55% | 0.75x | ❌ | -| `hexbytes_repr[single 0xff]` | 2.5412433661322482e-05 | 4.4486854740555556e-05 | -75.06% | -42.88% | 0.57x | ❌ | -| `hexbytes_repr[single null byte]` | 2.571699182079626e-05 | 4.427370703012172e-05 | -72.16% | -41.91% | 0.58x | ❌ | -| `hexbytes_repr[two patterns]` | 4.8579280895801936e-05 | 6.850903517262255e-05 | -41.03% | -29.09% | 0.71x | ❌ | -| `hexbytes_to_0x_hex[0-9]` | 1.551396585047557e-05 | 1.3630300793019073e-05 | 12.14% | 13.82% | 1.14x | ✅ | -| `hexbytes_to_0x_hex[4-byte pattern]` | 4.195234456795008e-05 | 4.012706081221306e-05 | 4.35% | 4.55% | 1.05x | ✅ | -| `hexbytes_to_0x_hex[all byte values]` | 4.211303275401072e-05 | 4.028452591251296e-05 | 4.34% | 4.54% | 1.05x | ✅ | -| `hexbytes_to_0x_hex[alternating 0x00/0xff]` | 2.0800595554670752e-05 | 1.9010172893267305e-05 | 8.61% | 9.42% | 1.09x | ✅ | -| `hexbytes_to_0x_hex[alternating 0xaa/0x55]` | 2.0904581121842868e-05 | 1.9147459039671937e-05 | 8.41% | 9.18% | 1.09x | ✅ | -| `hexbytes_to_0x_hex[ascii sentence]` | 1.885077859672098e-05 | 1.7071625813539214e-05 | 9.44% | 10.42% | 1.10x | ✅ | -| `hexbytes_to_0x_hex[b'']` | 1.026480036137029e-05 | 1.1345847549565756e-05 | -10.53% | -9.53% | 0.90x | ❌ | -| `hexbytes_to_0x_hex[b'\\x00'*32]` | 1.7477926479293212e-05 | 1.583933858505862e-05 | 9.38% | 10.35% | 1.10x | ✅ | -| `hexbytes_to_0x_hex[b'\\x00\\xff\\x00\\xff']` | 1.5048574884238393e-05 | 1.3065242835046563e-05 | 13.18% | 15.18% | 1.15x | ✅ | -| `hexbytes_to_0x_hex[b'\\x01'*100]` | 2.5080113367605668e-05 | 2.2536233916689552e-05 | 10.14% | 11.29% | 1.11x | ✅ | -| `hexbytes_to_0x_hex[b'\\x01'*2048]` | 0.00022120556912250792 | 0.0002211920219665213 | 0.01% | 0.01% | 1.00x | ✅ | -| `hexbytes_to_0x_hex[b'\\x01\\x02\\x03']` | 1.484649658669481e-05 | 1.3091211127426347e-05 | 11.82% | 13.41% | 1.13x | ✅ | -| `hexbytes_to_0x_hex[b'\\x10\\x20\\x30\\x40\\x50']` | 1.5047836277518734e-05 | 1.3107099760095945e-05 | 12.90% | 14.81% | 1.15x | ✅ | -| `hexbytes_to_0x_hex[b'\\x7f'*8]` | 1.5407694127854997e-05 | 1.354045064787356e-05 | 12.12% | 13.79% | 1.14x | ✅ | -| `hexbytes_to_0x_hex[b'\\x80'*8]` | 1.5428943320727377e-05 | 1.3440175575873593e-05 | 12.89% | 14.80% | 1.15x | ✅ | -| `hexbytes_to_0x_hex[b'\\xde\\xad\\xbe\\xef']` | 1.5012446645307307e-05 | 1.313473795929436e-05 | 12.51% | 14.30% | 1.14x | ✅ | -| `hexbytes_to_0x_hex[b'\\xff'*64]` | 2.0806946366311905e-05 | 1.92471000032091e-05 | 7.50% | 8.10% | 1.08x | ✅ | -| `hexbytes_to_0x_hex[b'a'*1024]` | 0.0001223788737133279 | 0.00011830648768577156 | 3.33% | 3.44% | 1.03x | ✅ | -| `hexbytes_to_0x_hex[b'abc']` | 1.5010069965050508e-05 | 1.3101622063792088e-05 | 12.71% | 14.57% | 1.15x | ✅ | -| `hexbytes_to_0x_hex[long alternating]` | 0.00012198009534447016 | 0.00012121568938859308 | 0.63% | 0.63% | 1.01x | ✅ | -| `hexbytes_to_0x_hex[mixed pattern]` | 3.4878635442167046e-05 | 3.308848224624071e-05 | 5.13% | 5.41% | 1.05x | ✅ | -| `hexbytes_to_0x_hex[multiples of 0x10]` | 1.5537679378131247e-05 | 1.3550212089721784e-05 | 12.79% | 14.67% | 1.15x | ✅ | -| `hexbytes_to_0x_hex[palindrome ascii]` | 1.526067072378255e-05 | 1.3441697074053967e-05 | 11.92% | 13.53% | 1.14x | ✅ | -| `hexbytes_to_0x_hex[palindrome numeric]` | 1.4922041049843883e-05 | 1.3376076252462054e-05 | 10.36% | 11.56% | 1.12x | ✅ | -| `hexbytes_to_0x_hex[palindrome]` | 1.6556797581452576e-05 | 1.4670629146908296e-05 | 11.39% | 12.86% | 1.13x | ✅ | -| `hexbytes_to_0x_hex[repeated 0-9]` | 2.5101944937213006e-05 | 2.2453825049654264e-05 | 10.55% | 11.79% | 1.12x | ✅ | -| `hexbytes_to_0x_hex[single 0xff]` | 1.4652719088638188e-05 | 1.2820154930984992e-05 | 12.51% | 14.29% | 1.14x | ✅ | -| `hexbytes_to_0x_hex[single null byte]` | 1.4640124525707886e-05 | 1.2928737904935405e-05 | 11.69% | 13.24% | 1.13x | ✅ | -| `hexbytes_to_0x_hex[two patterns]` | 2.076404064230241e-05 | 1.8906706862571387e-05 | 8.94% | 9.82% | 1.10x | ✅ | +| `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 | ✅ |