From 7f9263935f8783957696b1a268dbbe4286bf663b Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Wed, 8 Oct 2025 22:23:17 -0400 Subject: [PATCH 1/5] Update utils.py --- faster_ens/utils.py | 36 +++++++++++++++++++++++++++++++++++- 1 file changed, 35 insertions(+), 1 deletion(-) diff --git a/faster_ens/utils.py b/faster_ens/utils.py index bf03e062f1..abd514ef38 100644 --- a/faster_ens/utils.py +++ b/faster_ens/utils.py @@ -2,6 +2,9 @@ datetime, timezone, ) +from functools import ( + singledispatch, +) from typing import ( TYPE_CHECKING, Any, @@ -197,11 +200,20 @@ def to_utc_datetime(timestamp: float) -> Optional[datetime]: return datetime.fromtimestamp(timestamp, timezone.utc) if timestamp else None +@singledispatch def sha3_text(val: Union[str, bytes]) -> HexBytes: if isinstance(val, str): val = val.encode("utf-8") return Web3().keccak(val) +@sha3_text.register(str) +def _(val: str) -> HexBytes: + return Web3().keccak(val.encode("utf-8")) + +@sha3_text.register(bytes) +def _(val: bytes) -> HexBytes: + return Web3().keccak(val) + def label_to_hash(label: str) -> HexBytes: label = normalize_name(label) @@ -276,13 +288,35 @@ def assert_signer_in_modifier_kwargs(modifier_kwargs: Any) -> ChecksumAddress: return modifier_dict["from"] +@singledispatch def is_none_or_zero_address(addr: Union[Address, ChecksumAddress, HexAddress, None]) -> bool: return not addr or addr == EMPTY_ADDR_HEX +@is_none_or_zero_address.register(bytes) +def _(addr: bytes) -> bool: + return not addr + +@is_none_or_zero_address.register(str) +def _(addr: str) -> bool: + return not addr or addr == EMPTY_ADDR_HEX + +@is_none_or_zero_address.register(type(None)) +def _(addr: Literal[None]) -> bool: + return True + -def is_empty_name(name: str) -> bool: # sourcery skip: collection-into-set +@singledispatch +def is_empty_name(name: Optional[str]) -> bool: # sourcery skip: collection-into-set return name is None or name.strip() in ("", ".") +@is_empty_name.register(type(None)) +def _(name: Literal[None]) -> bool: # sourcery skip: collection-into-set + return True + +@is_empty_name.register(str) +def _(name: str) -> bool: # sourcery skip: collection-into-set + return name.strip() in ("", ".") + def is_valid_ens_name(ens_name: str) -> bool: split_domain = ens_name.split(".") From 1a32d29363f6514512e61bad94dc7616f0c9189a Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Wed, 8 Oct 2025 22:23:56 -0400 Subject: [PATCH 2/5] Update utils.py --- faster_ens/utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/faster_ens/utils.py b/faster_ens/utils.py index abd514ef38..d7ae68b511 100644 --- a/faster_ens/utils.py +++ b/faster_ens/utils.py @@ -9,6 +9,7 @@ TYPE_CHECKING, Any, Collection, + Literal, Optional, Sequence, Tuple, From c884d2347a0739dee251b1e5809f2ae68445310f Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Wed, 8 Oct 2025 22:27:08 -0400 Subject: [PATCH 3/5] Update utils.py --- faster_ens/utils.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/faster_ens/utils.py b/faster_ens/utils.py index d7ae68b511..9c6a3ee6ea 100644 --- a/faster_ens/utils.py +++ b/faster_ens/utils.py @@ -292,18 +292,18 @@ def assert_signer_in_modifier_kwargs(modifier_kwargs: Any) -> ChecksumAddress: @singledispatch def is_none_or_zero_address(addr: Union[Address, ChecksumAddress, HexAddress, None]) -> bool: return not addr or addr == EMPTY_ADDR_HEX - -@is_none_or_zero_address.register(bytes) -def _(addr: bytes) -> bool: - return not addr - -@is_none_or_zero_address.register(str) -def _(addr: str) -> bool: - return not addr or addr == EMPTY_ADDR_HEX @is_none_or_zero_address.register(type(None)) def _(addr: Literal[None]) -> bool: return True + +@is_none_or_zero_address.register(str) +def _(addr: str) -> bool: + return not addr or addr == EMPTY_ADDR_HEX + +@is_none_or_zero_address.register(bytes) +def _(addr: bytes) -> bool: + return not addr @singledispatch From 11c2b5c24b9628366e28091df13dc37c0d020cd9 Mon Sep 17 00:00:00 2001 From: BobTheBuidler <70677534+BobTheBuidler@users.noreply.github.com> Date: Wed, 8 Oct 2025 22:51:35 -0400 Subject: [PATCH 4/5] Update utils.py --- faster_ens/utils.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/faster_ens/utils.py b/faster_ens/utils.py index 9c6a3ee6ea..2a69dae205 100644 --- a/faster_ens/utils.py +++ b/faster_ens/utils.py @@ -208,11 +208,11 @@ def sha3_text(val: Union[str, bytes]) -> HexBytes: return Web3().keccak(val) @sha3_text.register(str) -def _(val: str) -> HexBytes: +def sha3_text_str(val: str) -> HexBytes: return Web3().keccak(val.encode("utf-8")) @sha3_text.register(bytes) -def _(val: bytes) -> HexBytes: +def sha3_text_bytes(val: bytes) -> HexBytes: return Web3().keccak(val) @@ -294,15 +294,15 @@ def is_none_or_zero_address(addr: Union[Address, ChecksumAddress, HexAddress, No return not addr or addr == EMPTY_ADDR_HEX @is_none_or_zero_address.register(type(None)) -def _(addr: Literal[None]) -> bool: +def is_none_or_zero_address_none(addr: Literal[None]) -> bool: return True @is_none_or_zero_address.register(str) -def _(addr: str) -> bool: +def is_none_or_zero_address_str(addr: str) -> bool: return not addr or addr == EMPTY_ADDR_HEX @is_none_or_zero_address.register(bytes) -def _(addr: bytes) -> bool: +def is_none_or_zero_address_bytes(addr: bytes) -> bool: return not addr @@ -311,11 +311,11 @@ def is_empty_name(name: Optional[str]) -> bool: # sourcery skip: collection-int return name is None or name.strip() in ("", ".") @is_empty_name.register(type(None)) -def _(name: Literal[None]) -> bool: # sourcery skip: collection-into-set +def is_empty_name_none(name: Literal[None]) -> bool: # sourcery skip: collection-into-set return True @is_empty_name.register(str) -def _(name: str) -> bool: # sourcery skip: collection-into-set +def is_empty_name_str(name: str) -> bool: # sourcery skip: collection-into-set return name.strip() in ("", ".") From 1f2822bcbb77d4b40a85caf35bc0a3bc0c06f328 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 9 Oct 2025 03:33:33 +0000 Subject: [PATCH 5/5] chore: compile C files for source control --- build/__native_f5f0329a7cb679764f9a.c | 5651 +++++++++++++---- build/__native_f5f0329a7cb679764f9a.h | 24 + .../__native_internal_f5f0329a7cb679764f9a.h | 56 +- 3 files changed, 4433 insertions(+), 1298 deletions(-) diff --git a/build/__native_f5f0329a7cb679764f9a.c b/build/__native_f5f0329a7cb679764f9a.c index 4040ca772f..1bf499bc59 100644 --- a/build/__native_f5f0329a7cb679764f9a.c +++ b/build/__native_f5f0329a7cb679764f9a.c @@ -13594,6 +13594,729 @@ CPyL24: ; cpy_r_r98 = 2; return cpy_r_r98; } + +static PyObject *CPyDunder___get__faster_ens___utils___sha3_text_obj(PyObject *self, PyObject *instance, PyObject *owner) { + instance = instance ? instance : Py_None; + return CPyDef_faster_ens___utils___sha3_text_obj_____get__(self, instance, owner); +} +static int +faster_ens___utils___sha3_text_obj_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + return 0; +} +PyObject *CPyDef_faster_ens___utils_____mypyc__sha3_text_obj_setup(PyObject *cpy_r_type); +PyObject *CPyDef_faster_ens___utils___sha3_text_obj(void); + +static PyObject * +faster_ens___utils___sha3_text_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (type != CPyType_faster_ens___utils___sha3_text_obj) { + PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled"); + return NULL; + } + PyObject *self = CPyDef_faster_ens___utils_____mypyc__sha3_text_obj_setup((PyObject*)type); + if (self == NULL) + return NULL; + PyObject *ret = CPyPy_faster_ens___utils___sha3_text_obj_____init__(self, args, kwds); + if (ret == NULL) + return NULL; + return self; +} + +static int +faster_ens___utils___sha3_text_obj_traverse(faster_ens___utils___sha3_text_objObject *self, visitproc visit, void *arg) +{ + Py_VISIT(self->_registry); + Py_VISIT(self->_dispatch_cache); + PyObject_VisitManagedDict((PyObject *)self, visit, arg); + return 0; +} + +static int +faster_ens___utils___sha3_text_obj_clear(faster_ens___utils___sha3_text_objObject *self) +{ + Py_CLEAR(self->_registry); + Py_CLEAR(self->_dispatch_cache); + PyObject_ClearManagedDict((PyObject *)self); + return 0; +} + +static void +faster_ens___utils___sha3_text_obj_dealloc(faster_ens___utils___sha3_text_objObject *self) +{ + PyObject_GC_UnTrack(self); + if (faster_ens___utils___sha3_text_obj_free_instance == NULL) { + faster_ens___utils___sha3_text_obj_free_instance = self; + Py_CLEAR(self->_registry); + Py_CLEAR(self->_dispatch_cache); + return; + } + CPy_TRASHCAN_BEGIN(self, faster_ens___utils___sha3_text_obj_dealloc) + faster_ens___utils___sha3_text_obj_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); + CPy_TRASHCAN_END(self) +} + +static CPyVTableItem faster_ens___utils___sha3_text_obj_vtable[4]; +static bool +CPyDef_faster_ens___utils___sha3_text_obj_trait_vtable_setup(void) +{ + CPyVTableItem faster_ens___utils___sha3_text_obj_vtable_scratch[] = { + (CPyVTableItem)CPyDef_faster_ens___utils___sha3_text_obj_____init__, + (CPyVTableItem)CPyDef_faster_ens___utils___sha3_text_obj_____call__, + (CPyVTableItem)CPyDef_faster_ens___utils___sha3_text_obj_____get__, + (CPyVTableItem)CPyDef_faster_ens___utils___sha3_text_obj___register, + }; + memcpy(faster_ens___utils___sha3_text_obj_vtable, faster_ens___utils___sha3_text_obj_vtable_scratch, sizeof(faster_ens___utils___sha3_text_obj_vtable)); + return 1; +} + +static PyObject * +faster_ens___utils___sha3_text_obj_get_registry(faster_ens___utils___sha3_text_objObject *self, void *closure); +static int +faster_ens___utils___sha3_text_obj_set_registry(faster_ens___utils___sha3_text_objObject *self, PyObject *value, void *closure); +static PyObject * +faster_ens___utils___sha3_text_obj_get_dispatch_cache(faster_ens___utils___sha3_text_objObject *self, void *closure); +static int +faster_ens___utils___sha3_text_obj_set_dispatch_cache(faster_ens___utils___sha3_text_objObject *self, PyObject *value, void *closure); + +static PyGetSetDef faster_ens___utils___sha3_text_obj_getseters[] = { + {"registry", + (getter)faster_ens___utils___sha3_text_obj_get_registry, (setter)faster_ens___utils___sha3_text_obj_set_registry, + NULL, NULL}, + {"dispatch_cache", + (getter)faster_ens___utils___sha3_text_obj_get_dispatch_cache, (setter)faster_ens___utils___sha3_text_obj_set_dispatch_cache, + NULL, NULL}, + {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict}, + {NULL} /* Sentinel */ +}; + +static PyMethodDef faster_ens___utils___sha3_text_obj_methods[] = { + {"__init__", + (PyCFunction)CPyPy_faster_ens___utils___sha3_text_obj_____init__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__init__()\n--\n\n")}, + {"__call__", + (PyCFunction)CPyPy_faster_ens___utils___sha3_text_obj_____call__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__call__($val)\n--\n\n")}, + {"__get__", + (PyCFunction)CPyPy_faster_ens___utils___sha3_text_obj_____get__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__get__($instance, owner)\n--\n\n")}, + {"register", + (PyCFunction)CPyPy_faster_ens___utils___sha3_text_obj___register, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR(NULL)}, + {"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL}, + {"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject CPyType_faster_ens___utils___sha3_text_obj_template_ = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "sha3_text_obj", + .tp_new = faster_ens___utils___sha3_text_obj_new, + .tp_dealloc = (destructor)faster_ens___utils___sha3_text_obj_dealloc, + .tp_traverse = (traverseproc)faster_ens___utils___sha3_text_obj_traverse, + .tp_clear = (inquiry)faster_ens___utils___sha3_text_obj_clear, + .tp_getset = faster_ens___utils___sha3_text_obj_getseters, + .tp_methods = faster_ens___utils___sha3_text_obj_methods, + .tp_call = PyVectorcall_Call, + .tp_descr_get = CPyDunder___get__faster_ens___utils___sha3_text_obj, + .tp_init = faster_ens___utils___sha3_text_obj_init, + .tp_basicsize = sizeof(faster_ens___utils___sha3_text_objObject), + .tp_vectorcall_offset = offsetof(faster_ens___utils___sha3_text_objObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_HAVE_VECTORCALL | Py_TPFLAGS_MANAGED_DICT, + .tp_doc = PyDoc_STR("sha3_text_obj()\n--\n\n"), +}; +static PyTypeObject *CPyType_faster_ens___utils___sha3_text_obj_template = &CPyType_faster_ens___utils___sha3_text_obj_template_; + +PyObject *CPyDef_faster_ens___utils_____mypyc__sha3_text_obj_setup(PyObject *cpy_r_type) +{ + PyTypeObject *type = (PyTypeObject*)cpy_r_type; + faster_ens___utils___sha3_text_objObject *self; + if (faster_ens___utils___sha3_text_obj_free_instance != NULL) { + self = faster_ens___utils___sha3_text_obj_free_instance; + faster_ens___utils___sha3_text_obj_free_instance = NULL; + Py_SET_REFCNT(self, 1); + PyObject_GC_Track(self); + return (PyObject *)self; + } + self = (faster_ens___utils___sha3_text_objObject *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + self->vtable = faster_ens___utils___sha3_text_obj_vtable; + self->vectorcall = CPyPy_faster_ens___utils___sha3_text_obj_____call__; + return (PyObject *)self; +} + +PyObject *CPyDef_faster_ens___utils___sha3_text_obj(void) +{ + PyObject *self = CPyDef_faster_ens___utils_____mypyc__sha3_text_obj_setup((PyObject *)CPyType_faster_ens___utils___sha3_text_obj); + if (self == NULL) + return NULL; + char res = CPyDef_faster_ens___utils___sha3_text_obj_____init__(self); + if (res == 2) { + Py_DECREF(self); + return NULL; + } + return self; +} + +static PyObject * +faster_ens___utils___sha3_text_obj_get_registry(faster_ens___utils___sha3_text_objObject *self, void *closure) +{ + if (unlikely(self->_registry == NULL)) { + PyErr_SetString(PyExc_AttributeError, + "attribute 'registry' of 'sha3_text_obj' undefined"); + return NULL; + } + CPy_INCREF(self->_registry); + PyObject *retval = self->_registry; + return retval; +} + +static int +faster_ens___utils___sha3_text_obj_set_registry(faster_ens___utils___sha3_text_objObject *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_AttributeError, + "'sha3_text_obj' object attribute 'registry' cannot be deleted"); + return -1; + } + if (self->_registry != NULL) { + CPy_DECREF(self->_registry); + } + PyObject *tmp; + if (likely(PyDict_Check(value))) + tmp = value; + else { + CPy_TypeError("dict", value); + tmp = NULL; + } + if (!tmp) + return -1; + CPy_INCREF(tmp); + self->_registry = tmp; + return 0; +} + +static PyObject * +faster_ens___utils___sha3_text_obj_get_dispatch_cache(faster_ens___utils___sha3_text_objObject *self, void *closure) +{ + if (unlikely(self->_dispatch_cache == NULL)) { + PyErr_SetString(PyExc_AttributeError, + "attribute 'dispatch_cache' of 'sha3_text_obj' undefined"); + return NULL; + } + CPy_INCREF(self->_dispatch_cache); + PyObject *retval = self->_dispatch_cache; + return retval; +} + +static int +faster_ens___utils___sha3_text_obj_set_dispatch_cache(faster_ens___utils___sha3_text_objObject *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_AttributeError, + "'sha3_text_obj' object attribute 'dispatch_cache' cannot be deleted"); + return -1; + } + if (self->_dispatch_cache != NULL) { + CPy_DECREF(self->_dispatch_cache); + } + PyObject *tmp; + if (likely(PyDict_Check(value))) + tmp = value; + else { + CPy_TypeError("dict", value); + tmp = NULL; + } + if (!tmp) + return -1; + CPy_INCREF(tmp); + self->_dispatch_cache = tmp; + return 0; +} + +static PyObject *CPyDunder___get__faster_ens___utils___is_none_or_zero_address_obj(PyObject *self, PyObject *instance, PyObject *owner) { + instance = instance ? instance : Py_None; + return CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____get__(self, instance, owner); +} +static int +faster_ens___utils___is_none_or_zero_address_obj_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + return 0; +} +PyObject *CPyDef_faster_ens___utils_____mypyc__is_none_or_zero_address_obj_setup(PyObject *cpy_r_type); +PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj(void); + +static PyObject * +faster_ens___utils___is_none_or_zero_address_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (type != CPyType_faster_ens___utils___is_none_or_zero_address_obj) { + PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled"); + return NULL; + } + PyObject *self = CPyDef_faster_ens___utils_____mypyc__is_none_or_zero_address_obj_setup((PyObject*)type); + if (self == NULL) + return NULL; + PyObject *ret = CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____init__(self, args, kwds); + if (ret == NULL) + return NULL; + return self; +} + +static int +faster_ens___utils___is_none_or_zero_address_obj_traverse(faster_ens___utils___is_none_or_zero_address_objObject *self, visitproc visit, void *arg) +{ + Py_VISIT(self->_registry); + Py_VISIT(self->_dispatch_cache); + PyObject_VisitManagedDict((PyObject *)self, visit, arg); + return 0; +} + +static int +faster_ens___utils___is_none_or_zero_address_obj_clear(faster_ens___utils___is_none_or_zero_address_objObject *self) +{ + Py_CLEAR(self->_registry); + Py_CLEAR(self->_dispatch_cache); + PyObject_ClearManagedDict((PyObject *)self); + return 0; +} + +static void +faster_ens___utils___is_none_or_zero_address_obj_dealloc(faster_ens___utils___is_none_or_zero_address_objObject *self) +{ + PyObject_GC_UnTrack(self); + if (faster_ens___utils___is_none_or_zero_address_obj_free_instance == NULL) { + faster_ens___utils___is_none_or_zero_address_obj_free_instance = self; + Py_CLEAR(self->_registry); + Py_CLEAR(self->_dispatch_cache); + return; + } + CPy_TRASHCAN_BEGIN(self, faster_ens___utils___is_none_or_zero_address_obj_dealloc) + faster_ens___utils___is_none_or_zero_address_obj_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); + CPy_TRASHCAN_END(self) +} + +static CPyVTableItem faster_ens___utils___is_none_or_zero_address_obj_vtable[4]; +static bool +CPyDef_faster_ens___utils___is_none_or_zero_address_obj_trait_vtable_setup(void) +{ + CPyVTableItem faster_ens___utils___is_none_or_zero_address_obj_vtable_scratch[] = { + (CPyVTableItem)CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____init__, + (CPyVTableItem)CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____call__, + (CPyVTableItem)CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____get__, + (CPyVTableItem)CPyDef_faster_ens___utils___is_none_or_zero_address_obj___register, + }; + memcpy(faster_ens___utils___is_none_or_zero_address_obj_vtable, faster_ens___utils___is_none_or_zero_address_obj_vtable_scratch, sizeof(faster_ens___utils___is_none_or_zero_address_obj_vtable)); + return 1; +} + +static PyObject * +faster_ens___utils___is_none_or_zero_address_obj_get_registry(faster_ens___utils___is_none_or_zero_address_objObject *self, void *closure); +static int +faster_ens___utils___is_none_or_zero_address_obj_set_registry(faster_ens___utils___is_none_or_zero_address_objObject *self, PyObject *value, void *closure); +static PyObject * +faster_ens___utils___is_none_or_zero_address_obj_get_dispatch_cache(faster_ens___utils___is_none_or_zero_address_objObject *self, void *closure); +static int +faster_ens___utils___is_none_or_zero_address_obj_set_dispatch_cache(faster_ens___utils___is_none_or_zero_address_objObject *self, PyObject *value, void *closure); + +static PyGetSetDef faster_ens___utils___is_none_or_zero_address_obj_getseters[] = { + {"registry", + (getter)faster_ens___utils___is_none_or_zero_address_obj_get_registry, (setter)faster_ens___utils___is_none_or_zero_address_obj_set_registry, + NULL, NULL}, + {"dispatch_cache", + (getter)faster_ens___utils___is_none_or_zero_address_obj_get_dispatch_cache, (setter)faster_ens___utils___is_none_or_zero_address_obj_set_dispatch_cache, + NULL, NULL}, + {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict}, + {NULL} /* Sentinel */ +}; + +static PyMethodDef faster_ens___utils___is_none_or_zero_address_obj_methods[] = { + {"__init__", + (PyCFunction)CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____init__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__init__()\n--\n\n")}, + {"__call__", + (PyCFunction)CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____call__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__call__($addr)\n--\n\n")}, + {"__get__", + (PyCFunction)CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____get__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__get__($instance, owner)\n--\n\n")}, + {"register", + (PyCFunction)CPyPy_faster_ens___utils___is_none_or_zero_address_obj___register, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR(NULL)}, + {"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL}, + {"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject CPyType_faster_ens___utils___is_none_or_zero_address_obj_template_ = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "is_none_or_zero_address_obj", + .tp_new = faster_ens___utils___is_none_or_zero_address_obj_new, + .tp_dealloc = (destructor)faster_ens___utils___is_none_or_zero_address_obj_dealloc, + .tp_traverse = (traverseproc)faster_ens___utils___is_none_or_zero_address_obj_traverse, + .tp_clear = (inquiry)faster_ens___utils___is_none_or_zero_address_obj_clear, + .tp_getset = faster_ens___utils___is_none_or_zero_address_obj_getseters, + .tp_methods = faster_ens___utils___is_none_or_zero_address_obj_methods, + .tp_call = PyVectorcall_Call, + .tp_descr_get = CPyDunder___get__faster_ens___utils___is_none_or_zero_address_obj, + .tp_init = faster_ens___utils___is_none_or_zero_address_obj_init, + .tp_basicsize = sizeof(faster_ens___utils___is_none_or_zero_address_objObject), + .tp_vectorcall_offset = offsetof(faster_ens___utils___is_none_or_zero_address_objObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_HAVE_VECTORCALL | Py_TPFLAGS_MANAGED_DICT, + .tp_doc = PyDoc_STR("is_none_or_zero_address_obj()\n--\n\n"), +}; +static PyTypeObject *CPyType_faster_ens___utils___is_none_or_zero_address_obj_template = &CPyType_faster_ens___utils___is_none_or_zero_address_obj_template_; + +PyObject *CPyDef_faster_ens___utils_____mypyc__is_none_or_zero_address_obj_setup(PyObject *cpy_r_type) +{ + PyTypeObject *type = (PyTypeObject*)cpy_r_type; + faster_ens___utils___is_none_or_zero_address_objObject *self; + if (faster_ens___utils___is_none_or_zero_address_obj_free_instance != NULL) { + self = faster_ens___utils___is_none_or_zero_address_obj_free_instance; + faster_ens___utils___is_none_or_zero_address_obj_free_instance = NULL; + Py_SET_REFCNT(self, 1); + PyObject_GC_Track(self); + return (PyObject *)self; + } + self = (faster_ens___utils___is_none_or_zero_address_objObject *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + self->vtable = faster_ens___utils___is_none_or_zero_address_obj_vtable; + self->vectorcall = CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____call__; + return (PyObject *)self; +} + +PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj(void) +{ + PyObject *self = CPyDef_faster_ens___utils_____mypyc__is_none_or_zero_address_obj_setup((PyObject *)CPyType_faster_ens___utils___is_none_or_zero_address_obj); + if (self == NULL) + return NULL; + char res = CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____init__(self); + if (res == 2) { + Py_DECREF(self); + return NULL; + } + return self; +} + +static PyObject * +faster_ens___utils___is_none_or_zero_address_obj_get_registry(faster_ens___utils___is_none_or_zero_address_objObject *self, void *closure) +{ + if (unlikely(self->_registry == NULL)) { + PyErr_SetString(PyExc_AttributeError, + "attribute 'registry' of 'is_none_or_zero_address_obj' undefined"); + return NULL; + } + CPy_INCREF(self->_registry); + PyObject *retval = self->_registry; + return retval; +} + +static int +faster_ens___utils___is_none_or_zero_address_obj_set_registry(faster_ens___utils___is_none_or_zero_address_objObject *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_AttributeError, + "'is_none_or_zero_address_obj' object attribute 'registry' cannot be deleted"); + return -1; + } + if (self->_registry != NULL) { + CPy_DECREF(self->_registry); + } + PyObject *tmp; + if (likely(PyDict_Check(value))) + tmp = value; + else { + CPy_TypeError("dict", value); + tmp = NULL; + } + if (!tmp) + return -1; + CPy_INCREF(tmp); + self->_registry = tmp; + return 0; +} + +static PyObject * +faster_ens___utils___is_none_or_zero_address_obj_get_dispatch_cache(faster_ens___utils___is_none_or_zero_address_objObject *self, void *closure) +{ + if (unlikely(self->_dispatch_cache == NULL)) { + PyErr_SetString(PyExc_AttributeError, + "attribute 'dispatch_cache' of 'is_none_or_zero_address_obj' undefined"); + return NULL; + } + CPy_INCREF(self->_dispatch_cache); + PyObject *retval = self->_dispatch_cache; + return retval; +} + +static int +faster_ens___utils___is_none_or_zero_address_obj_set_dispatch_cache(faster_ens___utils___is_none_or_zero_address_objObject *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_AttributeError, + "'is_none_or_zero_address_obj' object attribute 'dispatch_cache' cannot be deleted"); + return -1; + } + if (self->_dispatch_cache != NULL) { + CPy_DECREF(self->_dispatch_cache); + } + PyObject *tmp; + if (likely(PyDict_Check(value))) + tmp = value; + else { + CPy_TypeError("dict", value); + tmp = NULL; + } + if (!tmp) + return -1; + CPy_INCREF(tmp); + self->_dispatch_cache = tmp; + return 0; +} + +static PyObject *CPyDunder___get__faster_ens___utils___is_empty_name_obj(PyObject *self, PyObject *instance, PyObject *owner) { + instance = instance ? instance : Py_None; + return CPyDef_faster_ens___utils___is_empty_name_obj_____get__(self, instance, owner); +} +static int +faster_ens___utils___is_empty_name_obj_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + return 0; +} +PyObject *CPyDef_faster_ens___utils_____mypyc__is_empty_name_obj_setup(PyObject *cpy_r_type); +PyObject *CPyDef_faster_ens___utils___is_empty_name_obj(void); + +static PyObject * +faster_ens___utils___is_empty_name_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (type != CPyType_faster_ens___utils___is_empty_name_obj) { + PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled"); + return NULL; + } + PyObject *self = CPyDef_faster_ens___utils_____mypyc__is_empty_name_obj_setup((PyObject*)type); + if (self == NULL) + return NULL; + PyObject *ret = CPyPy_faster_ens___utils___is_empty_name_obj_____init__(self, args, kwds); + if (ret == NULL) + return NULL; + return self; +} + +static int +faster_ens___utils___is_empty_name_obj_traverse(faster_ens___utils___is_empty_name_objObject *self, visitproc visit, void *arg) +{ + Py_VISIT(self->_registry); + Py_VISIT(self->_dispatch_cache); + PyObject_VisitManagedDict((PyObject *)self, visit, arg); + return 0; +} + +static int +faster_ens___utils___is_empty_name_obj_clear(faster_ens___utils___is_empty_name_objObject *self) +{ + Py_CLEAR(self->_registry); + Py_CLEAR(self->_dispatch_cache); + PyObject_ClearManagedDict((PyObject *)self); + return 0; +} + +static void +faster_ens___utils___is_empty_name_obj_dealloc(faster_ens___utils___is_empty_name_objObject *self) +{ + PyObject_GC_UnTrack(self); + if (faster_ens___utils___is_empty_name_obj_free_instance == NULL) { + faster_ens___utils___is_empty_name_obj_free_instance = self; + Py_CLEAR(self->_registry); + Py_CLEAR(self->_dispatch_cache); + return; + } + CPy_TRASHCAN_BEGIN(self, faster_ens___utils___is_empty_name_obj_dealloc) + faster_ens___utils___is_empty_name_obj_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); + CPy_TRASHCAN_END(self) +} + +static CPyVTableItem faster_ens___utils___is_empty_name_obj_vtable[4]; +static bool +CPyDef_faster_ens___utils___is_empty_name_obj_trait_vtable_setup(void) +{ + CPyVTableItem faster_ens___utils___is_empty_name_obj_vtable_scratch[] = { + (CPyVTableItem)CPyDef_faster_ens___utils___is_empty_name_obj_____init__, + (CPyVTableItem)CPyDef_faster_ens___utils___is_empty_name_obj_____call__, + (CPyVTableItem)CPyDef_faster_ens___utils___is_empty_name_obj_____get__, + (CPyVTableItem)CPyDef_faster_ens___utils___is_empty_name_obj___register, + }; + memcpy(faster_ens___utils___is_empty_name_obj_vtable, faster_ens___utils___is_empty_name_obj_vtable_scratch, sizeof(faster_ens___utils___is_empty_name_obj_vtable)); + return 1; +} + +static PyObject * +faster_ens___utils___is_empty_name_obj_get_registry(faster_ens___utils___is_empty_name_objObject *self, void *closure); +static int +faster_ens___utils___is_empty_name_obj_set_registry(faster_ens___utils___is_empty_name_objObject *self, PyObject *value, void *closure); +static PyObject * +faster_ens___utils___is_empty_name_obj_get_dispatch_cache(faster_ens___utils___is_empty_name_objObject *self, void *closure); +static int +faster_ens___utils___is_empty_name_obj_set_dispatch_cache(faster_ens___utils___is_empty_name_objObject *self, PyObject *value, void *closure); + +static PyGetSetDef faster_ens___utils___is_empty_name_obj_getseters[] = { + {"registry", + (getter)faster_ens___utils___is_empty_name_obj_get_registry, (setter)faster_ens___utils___is_empty_name_obj_set_registry, + NULL, NULL}, + {"dispatch_cache", + (getter)faster_ens___utils___is_empty_name_obj_get_dispatch_cache, (setter)faster_ens___utils___is_empty_name_obj_set_dispatch_cache, + NULL, NULL}, + {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict}, + {NULL} /* Sentinel */ +}; + +static PyMethodDef faster_ens___utils___is_empty_name_obj_methods[] = { + {"__init__", + (PyCFunction)CPyPy_faster_ens___utils___is_empty_name_obj_____init__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__init__()\n--\n\n")}, + {"__call__", + (PyCFunction)CPyPy_faster_ens___utils___is_empty_name_obj_____call__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__call__($name)\n--\n\n")}, + {"__get__", + (PyCFunction)CPyPy_faster_ens___utils___is_empty_name_obj_____get__, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__get__($instance, owner)\n--\n\n")}, + {"register", + (PyCFunction)CPyPy_faster_ens___utils___is_empty_name_obj___register, + METH_FASTCALL | METH_KEYWORDS, PyDoc_STR(NULL)}, + {"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL}, + {"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject CPyType_faster_ens___utils___is_empty_name_obj_template_ = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "is_empty_name_obj", + .tp_new = faster_ens___utils___is_empty_name_obj_new, + .tp_dealloc = (destructor)faster_ens___utils___is_empty_name_obj_dealloc, + .tp_traverse = (traverseproc)faster_ens___utils___is_empty_name_obj_traverse, + .tp_clear = (inquiry)faster_ens___utils___is_empty_name_obj_clear, + .tp_getset = faster_ens___utils___is_empty_name_obj_getseters, + .tp_methods = faster_ens___utils___is_empty_name_obj_methods, + .tp_call = PyVectorcall_Call, + .tp_descr_get = CPyDunder___get__faster_ens___utils___is_empty_name_obj, + .tp_init = faster_ens___utils___is_empty_name_obj_init, + .tp_basicsize = sizeof(faster_ens___utils___is_empty_name_objObject), + .tp_vectorcall_offset = offsetof(faster_ens___utils___is_empty_name_objObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_HAVE_VECTORCALL | Py_TPFLAGS_MANAGED_DICT, + .tp_doc = PyDoc_STR("is_empty_name_obj()\n--\n\n"), +}; +static PyTypeObject *CPyType_faster_ens___utils___is_empty_name_obj_template = &CPyType_faster_ens___utils___is_empty_name_obj_template_; + +PyObject *CPyDef_faster_ens___utils_____mypyc__is_empty_name_obj_setup(PyObject *cpy_r_type) +{ + PyTypeObject *type = (PyTypeObject*)cpy_r_type; + faster_ens___utils___is_empty_name_objObject *self; + if (faster_ens___utils___is_empty_name_obj_free_instance != NULL) { + self = faster_ens___utils___is_empty_name_obj_free_instance; + faster_ens___utils___is_empty_name_obj_free_instance = NULL; + Py_SET_REFCNT(self, 1); + PyObject_GC_Track(self); + return (PyObject *)self; + } + self = (faster_ens___utils___is_empty_name_objObject *)type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + self->vtable = faster_ens___utils___is_empty_name_obj_vtable; + self->vectorcall = CPyPy_faster_ens___utils___is_empty_name_obj_____call__; + return (PyObject *)self; +} + +PyObject *CPyDef_faster_ens___utils___is_empty_name_obj(void) +{ + PyObject *self = CPyDef_faster_ens___utils_____mypyc__is_empty_name_obj_setup((PyObject *)CPyType_faster_ens___utils___is_empty_name_obj); + if (self == NULL) + return NULL; + char res = CPyDef_faster_ens___utils___is_empty_name_obj_____init__(self); + if (res == 2) { + Py_DECREF(self); + return NULL; + } + return self; +} + +static PyObject * +faster_ens___utils___is_empty_name_obj_get_registry(faster_ens___utils___is_empty_name_objObject *self, void *closure) +{ + if (unlikely(self->_registry == NULL)) { + PyErr_SetString(PyExc_AttributeError, + "attribute 'registry' of 'is_empty_name_obj' undefined"); + return NULL; + } + CPy_INCREF(self->_registry); + PyObject *retval = self->_registry; + return retval; +} + +static int +faster_ens___utils___is_empty_name_obj_set_registry(faster_ens___utils___is_empty_name_objObject *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_AttributeError, + "'is_empty_name_obj' object attribute 'registry' cannot be deleted"); + return -1; + } + if (self->_registry != NULL) { + CPy_DECREF(self->_registry); + } + PyObject *tmp; + if (likely(PyDict_Check(value))) + tmp = value; + else { + CPy_TypeError("dict", value); + tmp = NULL; + } + if (!tmp) + return -1; + CPy_INCREF(tmp); + self->_registry = tmp; + return 0; +} + +static PyObject * +faster_ens___utils___is_empty_name_obj_get_dispatch_cache(faster_ens___utils___is_empty_name_objObject *self, void *closure) +{ + if (unlikely(self->_dispatch_cache == NULL)) { + PyErr_SetString(PyExc_AttributeError, + "attribute 'dispatch_cache' of 'is_empty_name_obj' undefined"); + return NULL; + } + CPy_INCREF(self->_dispatch_cache); + PyObject *retval = self->_dispatch_cache; + return retval; +} + +static int +faster_ens___utils___is_empty_name_obj_set_dispatch_cache(faster_ens___utils___is_empty_name_objObject *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_AttributeError, + "'is_empty_name_obj' object attribute 'dispatch_cache' cannot be deleted"); + return -1; + } + if (self->_dispatch_cache != NULL) { + CPy_DECREF(self->_dispatch_cache); + } + PyObject *tmp; + if (likely(PyDict_Check(value))) + tmp = value; + else { + CPy_TypeError("dict", value); + tmp = NULL; + } + if (!tmp) + return -1; + CPy_INCREF(tmp); + self->_dispatch_cache = tmp; + return 0; +} static PyMethodDef faster_ens___utilsmodule_methods[] = { {"Web3", (PyCFunction)CPyPy_faster_ens___utils___Web3, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("Web3()\n--\n\n") /* docstring */}, {"init_web3", (PyCFunction)CPyPy_faster_ens___utils___init_web3, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("init_web3(provider=None, middleware=None)\n--\n\n") /* docstring */}, @@ -13603,7 +14326,10 @@ static PyMethodDef faster_ens___utilsmodule_methods[] = { {"ens_encode_name", (PyCFunction)CPyPy_faster_ens___utils___ens_encode_name, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("ens_encode_name(name)\n--\n\n") /* docstring */}, {"is_valid_name", (PyCFunction)CPyPy_faster_ens___utils___is_valid_name, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_valid_name(name)\n--\n\n") /* docstring */}, {"to_utc_datetime", (PyCFunction)CPyPy_faster_ens___utils___to_utc_datetime, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("to_utc_datetime(timestamp)\n--\n\n") /* docstring */}, + {"__mypyc_singledispatch_main_function_sha3_text__", (PyCFunction)CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_sha3_text__, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__mypyc_singledispatch_main_function_sha3_text__(val)\n--\n\n") /* docstring */}, {"sha3_text", (PyCFunction)CPyPy_faster_ens___utils___sha3_text, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("sha3_text(val)\n--\n\n") /* docstring */}, + {"sha3_text_str", (PyCFunction)CPyPy_faster_ens___utils___sha3_text_str, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("sha3_text_str(val)\n--\n\n") /* docstring */}, + {"sha3_text_bytes", (PyCFunction)CPyPy_faster_ens___utils___sha3_text_bytes, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("sha3_text_bytes(val)\n--\n\n") /* docstring */}, {"label_to_hash", (PyCFunction)CPyPy_faster_ens___utils___label_to_hash, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("label_to_hash(label)\n--\n\n") /* docstring */}, {"normal_name_to_hash", (PyCFunction)CPyPy_faster_ens___utils___normal_name_to_hash, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("normal_name_to_hash(name)\n--\n\n") /* docstring */}, {"raw_name_to_hash", (PyCFunction)CPyPy_faster_ens___utils___raw_name_to_hash, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("raw_name_to_hash(name)\n--\n\n") /* docstring */}, @@ -13611,8 +14337,15 @@ static PyMethodDef faster_ens___utilsmodule_methods[] = { {"address_to_reverse_domain", (PyCFunction)CPyPy_faster_ens___utils___address_to_reverse_domain, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("address_to_reverse_domain(address)\n--\n\n") /* docstring */}, {"estimate_auction_start_gas", (PyCFunction)CPyPy_faster_ens___utils___estimate_auction_start_gas, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("estimate_auction_start_gas(labels)\n--\n\n") /* docstring */}, {"assert_signer_in_modifier_kwargs", (PyCFunction)CPyPy_faster_ens___utils___assert_signer_in_modifier_kwargs, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("assert_signer_in_modifier_kwargs(modifier_kwargs)\n--\n\n") /* docstring */}, + {"__mypyc_singledispatch_main_function_is_none_or_zero_address__", (PyCFunction)CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_is_none_or_zero_address__, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__mypyc_singledispatch_main_function_is_none_or_zero_address__(addr)\n--\n\n") /* docstring */}, {"is_none_or_zero_address", (PyCFunction)CPyPy_faster_ens___utils___is_none_or_zero_address, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_none_or_zero_address(addr)\n--\n\n") /* docstring */}, + {"is_none_or_zero_address_none", (PyCFunction)CPyPy_faster_ens___utils___is_none_or_zero_address_none, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_none_or_zero_address_none(addr)\n--\n\n") /* docstring */}, + {"is_none_or_zero_address_str", (PyCFunction)CPyPy_faster_ens___utils___is_none_or_zero_address_str, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_none_or_zero_address_str(addr)\n--\n\n") /* docstring */}, + {"is_none_or_zero_address_bytes", (PyCFunction)CPyPy_faster_ens___utils___is_none_or_zero_address_bytes, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_none_or_zero_address_bytes(addr)\n--\n\n") /* docstring */}, + {"__mypyc_singledispatch_main_function_is_empty_name__", (PyCFunction)CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_is_empty_name__, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("__mypyc_singledispatch_main_function_is_empty_name__(name)\n--\n\n") /* docstring */}, {"is_empty_name", (PyCFunction)CPyPy_faster_ens___utils___is_empty_name, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_empty_name(name)\n--\n\n") /* docstring */}, + {"is_empty_name_none", (PyCFunction)CPyPy_faster_ens___utils___is_empty_name_none, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_empty_name_none(name)\n--\n\n") /* docstring */}, + {"is_empty_name_str", (PyCFunction)CPyPy_faster_ens___utils___is_empty_name_str, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_empty_name_str(name)\n--\n\n") /* docstring */}, {"is_valid_ens_name", (PyCFunction)CPyPy_faster_ens___utils___is_valid_ens_name, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("is_valid_ens_name(ens_name)\n--\n\n") /* docstring */}, {"init_async_web3", (PyCFunction)CPyPy_faster_ens___utils___init_async_web3, METH_FASTCALL | METH_KEYWORDS, PyDoc_STR("init_async_web3(provider=None, middleware=())\n--\n\n") /* docstring */}, {NULL, NULL, 0, NULL} @@ -13625,6 +14358,15 @@ int CPyExec_faster_ens___utils(PyObject *module) CPyStatic_faster_ens___utils___globals = PyModule_GetDict(CPyModule_faster_ens___utils__internal); if (unlikely(CPyStatic_faster_ens___utils___globals == NULL)) goto fail; + CPyType_faster_ens___utils___sha3_text_obj = (PyTypeObject *)CPyType_FromTemplate((PyObject *)CPyType_faster_ens___utils___sha3_text_obj_template, NULL, modname); + if (unlikely(!CPyType_faster_ens___utils___sha3_text_obj)) + goto fail; + CPyType_faster_ens___utils___is_none_or_zero_address_obj = (PyTypeObject *)CPyType_FromTemplate((PyObject *)CPyType_faster_ens___utils___is_none_or_zero_address_obj_template, NULL, modname); + if (unlikely(!CPyType_faster_ens___utils___is_none_or_zero_address_obj)) + goto fail; + CPyType_faster_ens___utils___is_empty_name_obj = (PyTypeObject *)CPyType_FromTemplate((PyObject *)CPyType_faster_ens___utils___is_empty_name_obj_template, NULL, modname); + if (unlikely(!CPyType_faster_ens___utils___is_empty_name_obj)) + goto fail; if (CPyGlobalsInit() < 0) goto fail; char result = CPyDef_faster_ens___utils_____top_level__(); @@ -13635,6 +14377,9 @@ int CPyExec_faster_ens___utils(PyObject *module) fail: Py_CLEAR(CPyModule_faster_ens___utils__internal); Py_CLEAR(modname); + Py_CLEAR(CPyType_faster_ens___utils___sha3_text_obj); + Py_CLEAR(CPyType_faster_ens___utils___is_none_or_zero_address_obj); + Py_CLEAR(CPyType_faster_ens___utils___is_empty_name_obj); return -1; } static struct PyModuleDef faster_ens___utilsmodule = { @@ -14236,7 +14981,7 @@ CPyL4: ; if (likely(PyUnicode_Check(cpy_r_r19))) cpy_r_r20 = cpy_r_r19; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "normalize_name", 129, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r19); + CPy_TypeErrorTraceback("faster_ens/utils.py", "normalize_name", 133, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r19); goto CPyL13; } cpy_r_name = cpy_r_r20; @@ -14425,7 +15170,7 @@ CPyL8: ; if (likely(PyUnicode_Check(cpy_r_r20))) cpy_r_r21 = cpy_r_r20; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 154, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r20); + CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 158, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r20); goto CPyL45; } cpy_r_r22 = CPyStr_Size_size_t(cpy_r_r21); @@ -14508,7 +15253,7 @@ CPyL21: ; if (likely(PyUnicode_Check(cpy_r_r49))) cpy_r_r50 = cpy_r_r49; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 161, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r49); + CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 165, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r49); goto CPyL51; } cpy_r_r51 = CPyStatic_faster_ens___utils___globals; @@ -14531,7 +15276,7 @@ CPyL21: ; if (likely(PyBytes_Check(cpy_r_r57) || PyByteArray_Check(cpy_r_r57))) cpy_r_r58 = cpy_r_r57; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 161, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r57); + CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 165, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r57); goto CPyL51; } CPyList_SetItemUnsafe(cpy_r_r40, cpy_r_r41, cpy_r_r58); @@ -14562,7 +15307,7 @@ CPyL31: ; if (likely(PyBytes_Check(cpy_r_r63) || PyByteArray_Check(cpy_r_r63))) cpy_r_r64 = cpy_r_r63; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 162, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r63); + CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 166, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r63); goto CPyL56; } cpy_r_r65 = (CPyPtr)&((PyVarObject *)cpy_r_r64)->ob_size; @@ -14588,7 +15333,7 @@ CPyL31: ; if (likely(PyBytes_Check(cpy_r_r74) || PyByteArray_Check(cpy_r_r74))) cpy_r_r75 = cpy_r_r74; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 162, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r74); + CPy_TypeErrorTraceback("faster_ens/utils.py", "dns_encode_name", 166, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r74); goto CPyL57; } cpy_r_r76 = CPyBytes_Concat(cpy_r_r75, cpy_r_r64); @@ -14787,7 +15532,7 @@ CPyL3: ; if (likely(PyBytes_Check(cpy_r_r16) || PyByteArray_Check(cpy_r_r16))) cpy_r_r17 = cpy_r_r16; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "ens_encode_name", 175, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r16); + CPy_TypeErrorTraceback("faster_ens/utils.py", "ens_encode_name", 179, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r16); goto CPyL7; } return cpy_r_r17; @@ -15015,7 +15760,7 @@ fail: ; return NULL; } -PyObject *CPyDef_faster_ens___utils___sha3_text(PyObject *cpy_r_val) { +PyObject *CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_sha3_text__(PyObject *cpy_r_val) { char cpy_r_r0; PyObject *cpy_r_r1; PyObject *cpy_r_r2; @@ -15031,7 +15776,7 @@ PyObject *CPyDef_faster_ens___utils___sha3_text(PyObject *cpy_r_val) { if (likely(PyUnicode_Check(cpy_r_val))) cpy_r_r1 = cpy_r_val; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "sha3_text", 202, CPyStatic_faster_ens___utils___globals, "str", cpy_r_val); + CPy_TypeErrorTraceback("faster_ens/utils.py", "sha3_text", 207, CPyStatic_faster_ens___utils___globals, "str", cpy_r_val); goto CPyL8; } cpy_r_r2 = PyUnicode_AsUTF8String(cpy_r_r1); @@ -15050,7 +15795,7 @@ CPyL4: ; if (likely(PyBytes_Check(cpy_r_val) || PyByteArray_Check(cpy_r_val))) cpy_r_r4 = cpy_r_val; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "sha3_text", 203, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_val); + CPy_TypeErrorTraceback("faster_ens/utils.py", "sha3_text", 208, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_val); goto CPyL11; } cpy_r_r5 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'keccak' */ @@ -15082,9 +15827,9 @@ CPyL12: ; goto CPyL8; } -PyObject *CPyPy_faster_ens___utils___sha3_text(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { +PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_sha3_text__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { static const char * const kwlist[] = {"val", 0}; - static CPyArg_Parser parser = {"O:sha3_text", kwlist, 0}; + static CPyArg_Parser parser = {"O:__mypyc_singledispatch_main_function_sha3_text__", kwlist, 0}; PyObject *obj_val; if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_val)) { return NULL; @@ -15105,13 +15850,502 @@ PyObject *CPyPy_faster_ens___utils___sha3_text(PyObject *self, PyObject *const * CPy_TypeError("union[str, bytes]", obj_val); goto fail; __LL37: ; - PyObject *retval = CPyDef_faster_ens___utils___sha3_text(arg_val); + PyObject *retval = CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_sha3_text__(arg_val); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___sha3_text_obj_____init__(PyObject *cpy_r___mypyc_self__) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + int32_t cpy_r_r3; + char cpy_r_r4; + char cpy_r_r5; + cpy_r_r0 = PyDict_New(); + if (cpy_r_r0 == NULL) goto CPyL4; + ((faster_ens___utils___sha3_text_objObject *)cpy_r___mypyc_self__)->_registry = cpy_r_r0; + cpy_r_r1 = PyDict_New(); + if (cpy_r_r1 == NULL) goto CPyL4; + cpy_r_r2 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'dispatch_cache' */ + cpy_r_r3 = PyObject_SetAttr(cpy_r___mypyc_self__, cpy_r_r2, cpy_r_r1); + CPy_DECREF(cpy_r_r1); + cpy_r_r4 = cpy_r_r3 >= 0; + if (!cpy_r_r4) goto CPyL4; + return 1; +CPyL4: ; + cpy_r_r5 = 2; + return cpy_r_r5; +} + +PyObject *CPyPy_faster_ens___utils___sha3_text_obj_____init__(PyObject *self, PyObject *args, PyObject *kw) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {0}; + if (!CPyArg_ParseTupleAndKeywords(args, kw, "", "__init__", kwlist)) { + return NULL; + } + PyObject *arg___mypyc_self__; + if (likely(Py_TYPE(obj___mypyc_self__) == CPyType_faster_ens___utils___sha3_text_obj)) + arg___mypyc_self__ = obj___mypyc_self__; + else { + CPy_TypeError("faster_ens.utils.sha3_text_obj", obj___mypyc_self__); + goto fail; + } + char retval = CPyDef_faster_ens___utils___sha3_text_obj_____init__(arg___mypyc_self__); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "__init__", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___sha3_text_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_val) { + CPyPtr cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + char 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_r12; + PyObject *cpy_r_r13; + int32_t cpy_r_r14; + char cpy_r_r15; + PyObject *cpy_r_r16; + CPyPtr cpy_r_r17; + PyObject *cpy_r_r18; + char cpy_r_r19; + CPyTagged cpy_r_r20; + char cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + char cpy_r_r24; + PyObject *cpy_r_r25; + PyObject *cpy_r_r26; + PyObject **cpy_r_r28; + PyObject *cpy_r_r29; + PyObject *cpy_r_r30; + cpy_r_r0 = (CPyPtr)&((PyObject *)cpy_r_val)->ob_type; + cpy_r_r1 = *(PyObject * *)cpy_r_r0; + cpy_r_r2 = ((faster_ens___utils___sha3_text_objObject *)cpy_r___mypyc_self__)->_dispatch_cache; + if (unlikely(cpy_r_r2 == NULL)) { + CPy_AttributeError("faster_ens/utils.py", "sha3_text", "sha3_text_obj", "dispatch_cache", 205, CPyStatic_faster_ens___utils___globals); + goto CPyL21; + } + CPy_INCREF(cpy_r_r2); +CPyL1: ; + cpy_r_r3 = CPyDict_GetWithNone(cpy_r_r2, cpy_r_r1); + if (unlikely(cpy_r_r3 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + cpy_r_r4 = (PyObject *)&_Py_NoneStruct; + cpy_r_r5 = cpy_r_r3 != cpy_r_r4; + if (cpy_r_r5) { + goto CPyL23; + } else + goto CPyL24; +CPyL3: ; + cpy_r_r6 = cpy_r_r3; + goto CPyL8; +CPyL4: ; + cpy_r_r7 = CPyModule_functools; + cpy_r_r8 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_find_impl' */ + cpy_r_r9 = CPyObject_GetAttr(cpy_r_r7, cpy_r_r8); + if (unlikely(cpy_r_r9 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + cpy_r_r10 = ((faster_ens___utils___sha3_text_objObject *)cpy_r___mypyc_self__)->_registry; + CPy_INCREF(cpy_r_r10); + PyObject *cpy_r_r11[2] = {cpy_r_r1, cpy_r_r10}; + cpy_r_r12 = (PyObject **)&cpy_r_r11; + cpy_r_r13 = PyObject_Vectorcall(cpy_r_r9, cpy_r_r12, 2, 0); + CPy_DECREF(cpy_r_r9); + if (unlikely(cpy_r_r13 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL25; + } + CPy_DECREF(cpy_r_r10); + cpy_r_r14 = PyDict_SetItem(cpy_r_r2, cpy_r_r1, cpy_r_r13); + CPy_DECREF(cpy_r_r2); + cpy_r_r15 = cpy_r_r14 >= 0; + if (unlikely(!cpy_r_r15)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL26; + } + cpy_r_r6 = cpy_r_r13; +CPyL8: ; + cpy_r_r16 = (PyObject *)&PyLong_Type; + cpy_r_r17 = (CPyPtr)&((PyObject *)cpy_r_r6)->ob_type; + cpy_r_r18 = *(PyObject * *)cpy_r_r17; + cpy_r_r19 = cpy_r_r18 == cpy_r_r16; + if (!cpy_r_r19) goto CPyL19; + if (likely(PyLong_Check(cpy_r_r6))) + cpy_r_r20 = CPyTagged_FromObject(cpy_r_r6); + else { + CPy_TypeError("int", cpy_r_r6); cpy_r_r20 = CPY_INT_TAG; + } + CPy_DECREF(cpy_r_r6); + if (unlikely(cpy_r_r20 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL21; + } + cpy_r_r21 = cpy_r_r20 == 0; + if (cpy_r_r21) { + goto CPyL27; + } else + goto CPyL14; +CPyL11: ; + CPy_INCREF(cpy_r_val); + if (likely(PyUnicode_Check(cpy_r_val))) + cpy_r_r22 = cpy_r_val; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "sha3_text", 205, CPyStatic_faster_ens___utils___globals, "str", cpy_r_val); + goto CPyL21; + } + cpy_r_r23 = CPyDef_faster_ens___utils___sha3_text_str(cpy_r_r22); + CPy_DECREF(cpy_r_r22); + if (unlikely(cpy_r_r23 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL21; + } + return cpy_r_r23; +CPyL14: ; + cpy_r_r24 = cpy_r_r20 == 2; + CPyTagged_DECREF(cpy_r_r20); + if (!cpy_r_r24) goto CPyL18; + CPy_INCREF(cpy_r_val); + if (likely(PyBytes_Check(cpy_r_val) || PyByteArray_Check(cpy_r_val))) + cpy_r_r25 = cpy_r_val; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "sha3_text", 205, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_val); + goto CPyL21; + } + cpy_r_r26 = CPyDef_faster_ens___utils___sha3_text_bytes(cpy_r_r25); + CPy_DECREF(cpy_r_r25); + if (unlikely(cpy_r_r26 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL21; + } + return cpy_r_r26; +CPyL18: ; + CPy_Unreachable(); +CPyL19: ; + PyObject *cpy_r_r27[1] = {cpy_r_val}; + cpy_r_r28 = (PyObject **)&cpy_r_r27; + cpy_r_r29 = PyObject_Vectorcall(cpy_r_r6, cpy_r_r28, 1, 0); + CPy_DECREF(cpy_r_r6); + if (unlikely(cpy_r_r29 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL21; + } + return cpy_r_r29; +CPyL21: ; + cpy_r_r30 = NULL; + return cpy_r_r30; +CPyL22: ; + CPy_DecRef(cpy_r_r2); + goto CPyL21; +CPyL23: ; + CPy_DECREF(cpy_r_r2); + goto CPyL3; +CPyL24: ; + CPy_DECREF(cpy_r_r3); + goto CPyL4; +CPyL25: ; + CPy_DecRef(cpy_r_r2); + CPy_DecRef(cpy_r_r10); + goto CPyL21; +CPyL26: ; + CPy_DecRef(cpy_r_r13); + goto CPyL21; +CPyL27: ; + CPyTagged_DECREF(cpy_r_r20); + goto CPyL11; +} + +PyObject *CPyPy_faster_ens___utils___sha3_text_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"val", 0}; + static CPyArg_Parser parser = {"O:__call__", kwlist, 0}; + PyObject *obj_val; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, PyVectorcall_NARGS(nargs), kwnames, &parser, &obj_val)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_val; + if (PyUnicode_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL38; + if (PyBytes_Check(obj_val) || PyByteArray_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL38; + CPy_TypeError("union[str, bytes]", obj_val); + goto fail; +__LL38: ; + PyObject *retval = CPyDef_faster_ens___utils___sha3_text_obj_____call__(arg___mypyc_self__, arg_val); return retval; fail: ; CPy_AddTraceback("faster_ens/utils.py", "sha3_text", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); return NULL; } +PyObject *CPyDef_faster_ens___utils___sha3_text_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_faster_ens___utils___sha3_text_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_faster_ens___utils___sha3_text_obj_____get__(arg___mypyc_self__, arg_instance, arg_owner); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "__get__", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___sha3_text_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + cpy_r_r0 = CPySingledispatch_RegisterFunction(cpy_r___mypyc_self__, cpy_r_cls, cpy_r_func); + if (cpy_r_r0 == NULL) goto CPyL2; + return cpy_r_r0; +CPyL2: ; + cpy_r_r1 = NULL; + return cpy_r_r1; +} + +PyObject *CPyPy_faster_ens___utils___sha3_text_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"cls", "func", 0}; + static CPyArg_Parser parser = {"O|O:register", kwlist, 0}; + PyObject *obj_cls; + PyObject *obj_func = NULL; + if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_cls, &obj_func)) { + return NULL; + } + PyObject *arg___mypyc_self__; + if (likely(Py_TYPE(obj___mypyc_self__) == CPyType_faster_ens___utils___sha3_text_obj)) + arg___mypyc_self__ = obj___mypyc_self__; + else { + CPy_TypeError("faster_ens.utils.sha3_text_obj", obj___mypyc_self__); + goto fail; + } + PyObject *arg_cls = obj_cls; + PyObject *arg_func; + if (obj_func == NULL) { + arg_func = NULL; + } else { + arg_func = obj_func; + } + PyObject *retval = CPyDef_faster_ens___utils___sha3_text_obj___register(arg___mypyc_self__, arg_cls, arg_func); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "register", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___sha3_text(PyObject *cpy_r_val) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + cpy_r_r0 = CPyStatic_faster_ens___utils___globals; + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'sha3_text' */ + cpy_r_r2 = CPyDict_GetItem(cpy_r_r0, cpy_r_r1); + if (cpy_r_r2 == NULL) goto CPyL3; + cpy_r_r3 = CPyDef_faster_ens___utils___sha3_text_obj_____call__(cpy_r_r2, cpy_r_val); + CPy_DECREF(cpy_r_r2); + if (cpy_r_r3 == NULL) goto CPyL3; + return cpy_r_r3; +CPyL3: ; + cpy_r_r4 = NULL; + return cpy_r_r4; +} + +PyObject *CPyPy_faster_ens___utils___sha3_text(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"val", 0}; + static CPyArg_Parser parser = {"O:sha3_text", kwlist, 0}; + PyObject *obj_val; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_val)) { + return NULL; + } + PyObject *arg_val; + if (PyUnicode_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL39; + if (PyBytes_Check(obj_val) || PyByteArray_Check(obj_val)) + arg_val = obj_val; + else { + arg_val = NULL; + } + if (arg_val != NULL) goto __LL39; + CPy_TypeError("union[str, bytes]", obj_val); + goto fail; +__LL39: ; + PyObject *retval = CPyDef_faster_ens___utils___sha3_text(arg_val); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "sha3_text", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___sha3_text_str(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; + cpy_r_r0 = CPyDef_faster_ens___utils___Web3(); + if (unlikely(cpy_r_r0 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text_str", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL4; + } + cpy_r_r1 = PyUnicode_AsUTF8String(cpy_r_val); + if (unlikely(cpy_r_r1 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text_str", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL5; + } + cpy_r_r2 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'keccak' */ + PyObject *cpy_r_r3[2] = {cpy_r_r0, cpy_r_r1}; + cpy_r_r4 = (PyObject **)&cpy_r_r3; + cpy_r_r5 = PyObject_VectorcallMethod(cpy_r_r2, cpy_r_r4, 9223372036854775810ULL, 0); + if (unlikely(cpy_r_r5 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text_str", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL6; + } + CPy_DECREF(cpy_r_r0); + CPy_DECREF(cpy_r_r1); + return cpy_r_r5; +CPyL4: ; + cpy_r_r6 = NULL; + return cpy_r_r6; +CPyL5: ; + CPy_DecRef(cpy_r_r0); + goto CPyL4; +CPyL6: ; + CPy_DecRef(cpy_r_r0); + CPy_DecRef(cpy_r_r1); + goto CPyL4; +} + +PyObject *CPyPy_faster_ens___utils___sha3_text_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"val", 0}; + static CPyArg_Parser parser = {"O:sha3_text_str", kwlist, 0}; + PyObject *obj_val; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_val)) { + return NULL; + } + PyObject *arg_val; + if (likely(PyUnicode_Check(obj_val))) + arg_val = obj_val; + else { + CPy_TypeError("str", obj_val); + goto fail; + } + PyObject *retval = CPyDef_faster_ens___utils___sha3_text_str(arg_val); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "sha3_text_str", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___sha3_text_bytes(PyObject *cpy_r_val) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject **cpy_r_r3; + PyObject *cpy_r_r4; + PyObject *cpy_r_r5; + cpy_r_r0 = CPyDef_faster_ens___utils___Web3(); + if (unlikely(cpy_r_r0 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL3; + } + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'keccak' */ + PyObject *cpy_r_r2[2] = {cpy_r_r0, cpy_r_val}; + cpy_r_r3 = (PyObject **)&cpy_r_r2; + cpy_r_r4 = PyObject_VectorcallMethod(cpy_r_r1, cpy_r_r3, 9223372036854775810ULL, 0); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "sha3_text_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL4; + } + CPy_DECREF(cpy_r_r0); + return cpy_r_r4; +CPyL3: ; + cpy_r_r5 = NULL; + return cpy_r_r5; +CPyL4: ; + CPy_DecRef(cpy_r_r0); + goto CPyL3; +} + +PyObject *CPyPy_faster_ens___utils___sha3_text_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"val", 0}; + static CPyArg_Parser parser = {"O:sha3_text_bytes", kwlist, 0}; + PyObject *obj_val; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_val)) { + return NULL; + } + PyObject *arg_val; + if (likely(PyBytes_Check(obj_val) || PyByteArray_Check(obj_val))) + arg_val = obj_val; + else { + CPy_TypeError("bytes", obj_val); + goto fail; + } + PyObject *retval = CPyDef_faster_ens___utils___sha3_text_bytes(arg_val); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "sha3_text_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + PyObject *CPyDef_faster_ens___utils___label_to_hash(PyObject *cpy_r_label) { PyObject *cpy_r_r0; PyObject *cpy_r_r1; @@ -15175,7 +16409,7 @@ PyObject *CPyDef_faster_ens___utils___label_to_hash(PyObject *cpy_r_label) { if (likely(PyUnicode_Check(cpy_r_r12))) cpy_r_r13 = cpy_r_r12; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "label_to_hash", 209, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r12); + CPy_TypeErrorTraceback("faster_ens/utils.py", "label_to_hash", 222, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r12); goto CPyL14; } cpy_r_r14 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* " with a '.'" */ @@ -15358,7 +16592,7 @@ CPyL7: ; if (likely(PyUnicode_Check(cpy_r_r17))) cpy_r_r18 = cpy_r_r17; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "normal_name_to_hash", 225, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r17); + CPy_TypeErrorTraceback("faster_ens/utils.py", "normal_name_to_hash", 238, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r17); goto CPyL28; } cpy_r_r19 = CPyDef_faster_ens___utils___label_to_hash(cpy_r_r18); @@ -15403,13 +16637,13 @@ CPyL17: ; if (likely(PyBytes_Check(cpy_r_node) || PyByteArray_Check(cpy_r_node))) cpy_r_r25 = cpy_r_node; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "normal_name_to_hash", 229, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_node); + CPy_TypeErrorTraceback("faster_ens/utils.py", "normal_name_to_hash", 242, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_node); goto CPyL32; } if (likely(PyBytes_Check(cpy_r_r19) || PyByteArray_Check(cpy_r_r19))) cpy_r_r26 = cpy_r_r19; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "normal_name_to_hash", 229, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r19); + CPy_TypeErrorTraceback("faster_ens/utils.py", "normal_name_to_hash", 242, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_r19); goto CPyL33; } cpy_r_r27 = CPyBytes_Concat(cpy_r_r25, cpy_r_r26); @@ -15571,7 +16805,7 @@ CPyL1: ; if (likely(PyUnicode_Check(cpy_r_r2))) cpy_r_r3 = cpy_r_r2; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "address_in", 256, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r2); + CPy_TypeErrorTraceback("faster_ens/utils.py", "address_in", 269, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r2); goto CPyL12; } cpy_r_r4 = CPyStatic_faster_ens___utils___globals; @@ -15694,7 +16928,7 @@ PyObject *CPyDef_faster_ens___utils___address_to_reverse_domain(PyObject *cpy_r_ if (likely(PyUnicode_Check(cpy_r_r5))) cpy_r_r6 = cpy_r_r5; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "address_to_reverse_domain", 260, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r5); + CPy_TypeErrorTraceback("faster_ens/utils.py", "address_to_reverse_domain", 273, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r5); goto CPyL8; } cpy_r_r7 = CPyStatic_faster_ens___utils___globals; @@ -15716,7 +16950,7 @@ PyObject *CPyDef_faster_ens___utils___address_to_reverse_domain(PyObject *cpy_r_ if (likely(PyUnicode_Check(cpy_r_r12))) cpy_r_r13 = cpy_r_r12; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "address_to_reverse_domain", 260, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r12); + CPy_TypeErrorTraceback("faster_ens/utils.py", "address_to_reverse_domain", 273, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r12); goto CPyL8; } cpy_r_r14 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '.addr.reverse' */ @@ -15875,30 +17109,30 @@ CPyL6: ; goto CPyL20; } CPy_DECREF(cpy_r_r9); - PyObject *__tmp38; + PyObject *__tmp40; if (unlikely(!(PyTuple_Check(cpy_r_r13) && PyTuple_GET_SIZE(cpy_r_r13) == 2))) { - __tmp38 = NULL; - goto __LL39; - } - __tmp38 = PyTuple_GET_ITEM(cpy_r_r13, 0); - if (__tmp38 == NULL) goto __LL39; - __tmp38 = PyTuple_GET_ITEM(cpy_r_r13, 1); - if (__tmp38 == NULL) goto __LL39; - __tmp38 = cpy_r_r13; -__LL39: ; - if (unlikely(__tmp38 == NULL)) { + __tmp40 = NULL; + goto __LL41; + } + __tmp40 = PyTuple_GET_ITEM(cpy_r_r13, 0); + if (__tmp40 == NULL) goto __LL41; + __tmp40 = PyTuple_GET_ITEM(cpy_r_r13, 1); + if (__tmp40 == NULL) goto __LL41; + __tmp40 = cpy_r_r13; +__LL41: ; + if (unlikely(__tmp40 == NULL)) { CPy_TypeError("tuple[object, object]", cpy_r_r13); cpy_r_r14 = (tuple_T2OO) { NULL, NULL }; } else { - PyObject *__tmp40 = PyTuple_GET_ITEM(cpy_r_r13, 0); - CPy_INCREF(__tmp40); - PyObject *__tmp41; - __tmp41 = __tmp40; - cpy_r_r14.f0 = __tmp41; - PyObject *__tmp42 = PyTuple_GET_ITEM(cpy_r_r13, 1); + PyObject *__tmp42 = PyTuple_GET_ITEM(cpy_r_r13, 0); CPy_INCREF(__tmp42); PyObject *__tmp43; __tmp43 = __tmp42; - cpy_r_r14.f1 = __tmp43; + cpy_r_r14.f0 = __tmp43; + PyObject *__tmp44 = PyTuple_GET_ITEM(cpy_r_r13, 1); + CPy_INCREF(__tmp44); + PyObject *__tmp45; + __tmp45 = __tmp44; + cpy_r_r14.f1 = __tmp45; } CPy_DECREF(cpy_r_r13); if (unlikely(cpy_r_r14.f0 == NULL)) { @@ -15958,7 +17192,7 @@ CPyL15: ; if (likely(PyUnicode_Check(cpy_r_r31))) cpy_r_r32 = cpy_r_r31; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "assert_signer_in_modifier_kwargs", 276, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r31); + CPy_TypeErrorTraceback("faster_ens/utils.py", "assert_signer_in_modifier_kwargs", 289, CPyStatic_faster_ens___utils___globals, "str", cpy_r_r31); goto CPyL18; } return cpy_r_r32; @@ -15999,7 +17233,7 @@ fail: ; return NULL; } -char CPyDef_faster_ens___utils___is_none_or_zero_address(PyObject *cpy_r_addr) { +char CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_is_none_or_zero_address__(PyObject *cpy_r_addr) { int32_t cpy_r_r0; char cpy_r_r1; char cpy_r_r2; @@ -16027,16 +17261,16 @@ CPyL3: ; else { cpy_r_r4 = NULL; } - if (cpy_r_r4 != NULL) goto __LL44; + if (cpy_r_r4 != NULL) goto __LL46; if (PyUnicode_Check(cpy_r_addr)) cpy_r_r4 = cpy_r_addr; else { cpy_r_r4 = NULL; } - if (cpy_r_r4 != NULL) goto __LL44; - CPy_TypeErrorTraceback("faster_ens/utils.py", "is_none_or_zero_address", 280, CPyStatic_faster_ens___utils___globals, "union[bytes, str]", cpy_r_addr); + if (cpy_r_r4 != NULL) goto __LL46; + CPy_TypeErrorTraceback("faster_ens/utils.py", "is_none_or_zero_address", 294, CPyStatic_faster_ens___utils___globals, "union[bytes, str]", cpy_r_addr); goto CPyL11; -__LL44: ; +__LL46: ; cpy_r_r5 = CPyStatic_faster_ens___constants___EMPTY_ADDR_HEX; if (unlikely(cpy_r_r5 == NULL)) { goto CPyL12; @@ -16077,6 +17311,416 @@ CPyL12: ; goto CPyL5; } +PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_is_none_or_zero_address__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"addr", 0}; + static CPyArg_Parser parser = {"O:__mypyc_singledispatch_main_function_is_none_or_zero_address__", kwlist, 0}; + PyObject *obj_addr; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_addr)) { + return NULL; + } + PyObject *arg_addr; + if (PyBytes_Check(obj_addr) || PyByteArray_Check(obj_addr)) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL47; + if (PyUnicode_Check(obj_addr)) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL47; + if (obj_addr == Py_None) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL47; + CPy_TypeError("union[bytes, str, None]", obj_addr); + goto fail; +__LL47: ; + char retval = CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_is_none_or_zero_address__(arg_addr); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____init__(PyObject *cpy_r___mypyc_self__) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + int32_t cpy_r_r3; + char cpy_r_r4; + char cpy_r_r5; + cpy_r_r0 = PyDict_New(); + if (cpy_r_r0 == NULL) goto CPyL4; + ((faster_ens___utils___is_none_or_zero_address_objObject *)cpy_r___mypyc_self__)->_registry = cpy_r_r0; + cpy_r_r1 = PyDict_New(); + if (cpy_r_r1 == NULL) goto CPyL4; + cpy_r_r2 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'dispatch_cache' */ + cpy_r_r3 = PyObject_SetAttr(cpy_r___mypyc_self__, cpy_r_r2, cpy_r_r1); + CPy_DECREF(cpy_r_r1); + cpy_r_r4 = cpy_r_r3 >= 0; + if (!cpy_r_r4) goto CPyL4; + return 1; +CPyL4: ; + cpy_r_r5 = 2; + return cpy_r_r5; +} + +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____init__(PyObject *self, PyObject *args, PyObject *kw) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {0}; + if (!CPyArg_ParseTupleAndKeywords(args, kw, "", "__init__", kwlist)) { + return NULL; + } + PyObject *arg___mypyc_self__; + if (likely(Py_TYPE(obj___mypyc_self__) == CPyType_faster_ens___utils___is_none_or_zero_address_obj)) + arg___mypyc_self__ = obj___mypyc_self__; + else { + CPy_TypeError("faster_ens.utils.is_none_or_zero_address_obj", obj___mypyc_self__); + goto fail; + } + char retval = CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____init__(arg___mypyc_self__); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "__init__", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_addr) { + CPyPtr cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + char 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_r12; + PyObject *cpy_r_r13; + int32_t cpy_r_r14; + char cpy_r_r15; + PyObject *cpy_r_r16; + CPyPtr cpy_r_r17; + PyObject *cpy_r_r18; + char cpy_r_r19; + CPyTagged cpy_r_r20; + char cpy_r_r21; + PyObject *cpy_r_r22; + char cpy_r_r23; + char cpy_r_r24; + PyObject *cpy_r_r25; + char cpy_r_r26; + PyObject **cpy_r_r28; + PyObject *cpy_r_r29; + char cpy_r_r30; + char cpy_r_r31; + cpy_r_r0 = (CPyPtr)&((PyObject *)cpy_r_addr)->ob_type; + cpy_r_r1 = *(PyObject * *)cpy_r_r0; + cpy_r_r2 = ((faster_ens___utils___is_none_or_zero_address_objObject *)cpy_r___mypyc_self__)->_dispatch_cache; + if (unlikely(cpy_r_r2 == NULL)) { + CPy_AttributeError("faster_ens/utils.py", "is_none_or_zero_address", "is_none_or_zero_address_obj", "dispatch_cache", 293, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + CPy_INCREF(cpy_r_r2); +CPyL1: ; + cpy_r_r3 = CPyDict_GetWithNone(cpy_r_r2, cpy_r_r1); + if (unlikely(cpy_r_r3 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL23; + } + cpy_r_r4 = (PyObject *)&_Py_NoneStruct; + cpy_r_r5 = cpy_r_r3 != cpy_r_r4; + if (cpy_r_r5) { + goto CPyL24; + } else + goto CPyL25; +CPyL3: ; + cpy_r_r6 = cpy_r_r3; + goto CPyL8; +CPyL4: ; + cpy_r_r7 = CPyModule_functools; + cpy_r_r8 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_find_impl' */ + cpy_r_r9 = CPyObject_GetAttr(cpy_r_r7, cpy_r_r8); + if (unlikely(cpy_r_r9 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL23; + } + cpy_r_r10 = ((faster_ens___utils___is_none_or_zero_address_objObject *)cpy_r___mypyc_self__)->_registry; + CPy_INCREF(cpy_r_r10); + PyObject *cpy_r_r11[2] = {cpy_r_r1, cpy_r_r10}; + cpy_r_r12 = (PyObject **)&cpy_r_r11; + cpy_r_r13 = PyObject_Vectorcall(cpy_r_r9, cpy_r_r12, 2, 0); + CPy_DECREF(cpy_r_r9); + if (unlikely(cpy_r_r13 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL26; + } + CPy_DECREF(cpy_r_r10); + cpy_r_r14 = PyDict_SetItem(cpy_r_r2, cpy_r_r1, cpy_r_r13); + CPy_DECREF(cpy_r_r2); + cpy_r_r15 = cpy_r_r14 >= 0; + if (unlikely(!cpy_r_r15)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL27; + } + cpy_r_r6 = cpy_r_r13; +CPyL8: ; + cpy_r_r16 = (PyObject *)&PyLong_Type; + cpy_r_r17 = (CPyPtr)&((PyObject *)cpy_r_r6)->ob_type; + cpy_r_r18 = *(PyObject * *)cpy_r_r17; + cpy_r_r19 = cpy_r_r18 == cpy_r_r16; + if (!cpy_r_r19) goto CPyL19; + if (likely(PyLong_Check(cpy_r_r6))) + cpy_r_r20 = CPyTagged_FromObject(cpy_r_r6); + else { + CPy_TypeError("int", cpy_r_r6); cpy_r_r20 = CPY_INT_TAG; + } + CPy_DECREF(cpy_r_r6); + if (unlikely(cpy_r_r20 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + cpy_r_r21 = cpy_r_r20 == 0; + if (cpy_r_r21) { + goto CPyL28; + } else + goto CPyL14; +CPyL11: ; + CPy_INCREF(cpy_r_addr); + if (likely(PyUnicode_Check(cpy_r_addr))) + cpy_r_r22 = cpy_r_addr; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "is_none_or_zero_address", 293, CPyStatic_faster_ens___utils___globals, "str", cpy_r_addr); + goto CPyL22; + } + cpy_r_r23 = CPyDef_faster_ens___utils___is_none_or_zero_address_str(cpy_r_r22); + CPy_DECREF(cpy_r_r22); + if (unlikely(cpy_r_r23 == 2)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + return cpy_r_r23; +CPyL14: ; + cpy_r_r24 = cpy_r_r20 == 2; + CPyTagged_DECREF(cpy_r_r20); + if (!cpy_r_r24) goto CPyL18; + CPy_INCREF(cpy_r_addr); + if (likely(PyBytes_Check(cpy_r_addr) || PyByteArray_Check(cpy_r_addr))) + cpy_r_r25 = cpy_r_addr; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "is_none_or_zero_address", 293, CPyStatic_faster_ens___utils___globals, "bytes", cpy_r_addr); + goto CPyL22; + } + cpy_r_r26 = CPyDef_faster_ens___utils___is_none_or_zero_address_bytes(cpy_r_r25); + CPy_DECREF(cpy_r_r25); + if (unlikely(cpy_r_r26 == 2)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + return cpy_r_r26; +CPyL18: ; + CPy_Unreachable(); +CPyL19: ; + PyObject *cpy_r_r27[1] = {cpy_r_addr}; + cpy_r_r28 = (PyObject **)&cpy_r_r27; + cpy_r_r29 = PyObject_Vectorcall(cpy_r_r6, cpy_r_r28, 1, 0); + CPy_DECREF(cpy_r_r6); + if (unlikely(cpy_r_r29 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + if (unlikely(!PyBool_Check(cpy_r_r29))) { + CPy_TypeError("bool", cpy_r_r29); cpy_r_r30 = 2; + } else + cpy_r_r30 = cpy_r_r29 == Py_True; + CPy_DECREF(cpy_r_r29); + if (unlikely(cpy_r_r30 == 2)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + return cpy_r_r30; +CPyL22: ; + cpy_r_r31 = 2; + return cpy_r_r31; +CPyL23: ; + CPy_DecRef(cpy_r_r2); + goto CPyL22; +CPyL24: ; + CPy_DECREF(cpy_r_r2); + goto CPyL3; +CPyL25: ; + CPy_DECREF(cpy_r_r3); + goto CPyL4; +CPyL26: ; + CPy_DecRef(cpy_r_r2); + CPy_DecRef(cpy_r_r10); + goto CPyL22; +CPyL27: ; + CPy_DecRef(cpy_r_r13); + goto CPyL22; +CPyL28: ; + CPyTagged_DECREF(cpy_r_r20); + goto CPyL11; +} + +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"addr", 0}; + static CPyArg_Parser parser = {"O:__call__", kwlist, 0}; + PyObject *obj_addr; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, PyVectorcall_NARGS(nargs), kwnames, &parser, &obj_addr)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_addr; + if (PyBytes_Check(obj_addr) || PyByteArray_Check(obj_addr)) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL48; + if (PyUnicode_Check(obj_addr)) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL48; + if (obj_addr == Py_None) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL48; + CPy_TypeError("union[bytes, str, None]", obj_addr); + goto fail; +__LL48: ; + char retval = CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____call__(arg___mypyc_self__, arg_addr); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_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_faster_ens___utils___is_none_or_zero_address_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_faster_ens___utils___is_none_or_zero_address_obj_____get__(arg___mypyc_self__, arg_instance, arg_owner); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "__get__", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + cpy_r_r0 = CPySingledispatch_RegisterFunction(cpy_r___mypyc_self__, cpy_r_cls, cpy_r_func); + if (cpy_r_r0 == NULL) goto CPyL2; + return cpy_r_r0; +CPyL2: ; + cpy_r_r1 = NULL; + return cpy_r_r1; +} + +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"cls", "func", 0}; + static CPyArg_Parser parser = {"O|O:register", kwlist, 0}; + PyObject *obj_cls; + PyObject *obj_func = NULL; + if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_cls, &obj_func)) { + return NULL; + } + PyObject *arg___mypyc_self__; + if (likely(Py_TYPE(obj___mypyc_self__) == CPyType_faster_ens___utils___is_none_or_zero_address_obj)) + arg___mypyc_self__ = obj___mypyc_self__; + else { + CPy_TypeError("faster_ens.utils.is_none_or_zero_address_obj", obj___mypyc_self__); + goto fail; + } + PyObject *arg_cls = obj_cls; + PyObject *arg_func; + if (obj_func == NULL) { + arg_func = NULL; + } else { + arg_func = obj_func; + } + PyObject *retval = CPyDef_faster_ens___utils___is_none_or_zero_address_obj___register(arg___mypyc_self__, arg_cls, arg_func); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "register", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_none_or_zero_address(PyObject *cpy_r_addr) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + char cpy_r_r3; + char cpy_r_r4; + cpy_r_r0 = CPyStatic_faster_ens___utils___globals; + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_none_or_zero_address' */ + cpy_r_r2 = CPyDict_GetItem(cpy_r_r0, cpy_r_r1); + if (cpy_r_r2 == NULL) goto CPyL3; + cpy_r_r3 = CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____call__(cpy_r_r2, cpy_r_addr); + CPy_DECREF(cpy_r_r2); + if (cpy_r_r3 == 2) goto CPyL3; + return cpy_r_r3; +CPyL3: ; + cpy_r_r4 = 2; + return cpy_r_r4; +} + PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { static const char * const kwlist[] = {"addr", 0}; static CPyArg_Parser parser = {"O:is_none_or_zero_address", kwlist, 0}; @@ -16084,29 +17728,650 @@ PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address(PyObject *self, PyO if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_addr)) { return NULL; } - PyObject *arg_addr; - if (PyBytes_Check(obj_addr) || PyByteArray_Check(obj_addr)) - arg_addr = obj_addr; - else { - arg_addr = NULL; - } - if (arg_addr != NULL) goto __LL45; - if (PyUnicode_Check(obj_addr)) - arg_addr = obj_addr; - else { - arg_addr = NULL; - } - if (arg_addr != NULL) goto __LL45; - if (obj_addr == Py_None) - arg_addr = obj_addr; - else { - arg_addr = NULL; - } - if (arg_addr != NULL) goto __LL45; - CPy_TypeError("union[bytes, str, None]", obj_addr); - goto fail; -__LL45: ; - char retval = CPyDef_faster_ens___utils___is_none_or_zero_address(arg_addr); + PyObject *arg_addr; + if (PyBytes_Check(obj_addr) || PyByteArray_Check(obj_addr)) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL49; + if (PyUnicode_Check(obj_addr)) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL49; + if (obj_addr == Py_None) + arg_addr = obj_addr; + else { + arg_addr = NULL; + } + if (arg_addr != NULL) goto __LL49; + CPy_TypeError("union[bytes, str, None]", obj_addr); + goto fail; +__LL49: ; + char retval = CPyDef_faster_ens___utils___is_none_or_zero_address(arg_addr); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_none_or_zero_address_none(char cpy_r_addr) { + return 1; +} + +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_none(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"addr", 0}; + static CPyArg_Parser parser = {"O:is_none_or_zero_address_none", kwlist, 0}; + PyObject *obj_addr; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_addr)) { + return NULL; + } + char arg_addr; + if (unlikely(obj_addr != Py_None)) { + CPy_TypeError("None", obj_addr); goto fail; + } else + arg_addr = 1; + char retval = CPyDef_faster_ens___utils___is_none_or_zero_address_none(arg_addr); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address_none", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_none_or_zero_address_str(PyObject *cpy_r_addr) { + int32_t cpy_r_r0; + char cpy_r_r1; + char cpy_r_r2; + char cpy_r_r3; + PyObject *cpy_r_r4; + char cpy_r_r5; + char cpy_r_r6; + char cpy_r_r7; + cpy_r_r0 = PyObject_Not(cpy_r_addr); + cpy_r_r1 = cpy_r_r0 >= 0; + if (unlikely(!cpy_r_r1)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address_str", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL8; + } + cpy_r_r2 = cpy_r_r0; + if (!cpy_r_r2) goto CPyL3; + cpy_r_r3 = cpy_r_r2; + goto CPyL7; +CPyL3: ; + cpy_r_r4 = CPyStatic_faster_ens___constants___EMPTY_ADDR_HEX; + if (likely(cpy_r_r4 != NULL)) goto CPyL6; + PyErr_SetString(PyExc_NameError, "value for final name \"EMPTY_ADDR_HEX\" was not set"); + cpy_r_r5 = 0; + if (unlikely(!cpy_r_r5)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address_str", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL8; + } + CPy_Unreachable(); +CPyL6: ; + cpy_r_r6 = CPyStr_Equal(cpy_r_addr, cpy_r_r4); + cpy_r_r3 = cpy_r_r6; +CPyL7: ; + return cpy_r_r3; +CPyL8: ; + cpy_r_r7 = 2; + return cpy_r_r7; +} + +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"addr", 0}; + static CPyArg_Parser parser = {"O:is_none_or_zero_address_str", kwlist, 0}; + PyObject *obj_addr; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_addr)) { + return NULL; + } + PyObject *arg_addr; + if (likely(PyUnicode_Check(obj_addr))) + arg_addr = obj_addr; + else { + CPy_TypeError("str", obj_addr); + goto fail; + } + char retval = CPyDef_faster_ens___utils___is_none_or_zero_address_str(arg_addr); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address_str", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_none_or_zero_address_bytes(PyObject *cpy_r_addr) { + int32_t cpy_r_r0; + char cpy_r_r1; + char cpy_r_r2; + char cpy_r_r3; + cpy_r_r0 = PyObject_Not(cpy_r_addr); + cpy_r_r1 = cpy_r_r0 >= 0; + if (unlikely(!cpy_r_r1)) { + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL2; + } + cpy_r_r2 = cpy_r_r0; + return cpy_r_r2; +CPyL2: ; + cpy_r_r3 = 2; + return cpy_r_r3; +} + +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"addr", 0}; + static CPyArg_Parser parser = {"O:is_none_or_zero_address_bytes", kwlist, 0}; + PyObject *obj_addr; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_addr)) { + return NULL; + } + PyObject *arg_addr; + if (likely(PyBytes_Check(obj_addr) || PyByteArray_Check(obj_addr))) + arg_addr = obj_addr; + else { + CPy_TypeError("bytes", obj_addr); + goto fail; + } + char retval = CPyDef_faster_ens___utils___is_none_or_zero_address_bytes(arg_addr); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address_bytes", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_is_empty_name__(PyObject *cpy_r_name) { + PyObject *cpy_r_r0; + char cpy_r_r1; + char cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + PyObject *cpy_r_r5; + PyObject *cpy_r_r6; + char cpy_r_r7; + char cpy_r_r8; + char cpy_r_r9; + char cpy_r_r10; + cpy_r_r0 = (PyObject *)&_Py_NoneStruct; + cpy_r_r1 = cpy_r_name == cpy_r_r0; + if (!cpy_r_r1) goto CPyL2; + cpy_r_r2 = cpy_r_r1; + goto CPyL8; +CPyL2: ; + CPy_INCREF(cpy_r_name); + if (likely(cpy_r_name != Py_None)) + cpy_r_r3 = cpy_r_name; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "is_empty_name", 311, CPyStatic_faster_ens___utils___globals, "str", cpy_r_name); + goto CPyL9; + } + cpy_r_r4 = CPyStr_Strip(cpy_r_r3, 0); + CPy_DECREF(cpy_r_r3); + cpy_r_r5 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ + cpy_r_r6 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '.' */ + cpy_r_r7 = CPyStr_Equal(cpy_r_r4, cpy_r_r5); + if (cpy_r_r7) goto CPyL10; + cpy_r_r8 = CPyStr_Equal(cpy_r_r4, cpy_r_r6); + CPy_DECREF(cpy_r_r4); + if (cpy_r_r8) goto CPyL6; + cpy_r_r9 = 0; + goto CPyL7; +CPyL6: ; + cpy_r_r9 = 1; +CPyL7: ; + cpy_r_r2 = cpy_r_r9; +CPyL8: ; + return cpy_r_r2; +CPyL9: ; + cpy_r_r10 = 2; + return cpy_r_r10; +CPyL10: ; + CPy_DECREF(cpy_r_r4); + goto CPyL6; +} + +PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_is_empty_name__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"name", 0}; + static CPyArg_Parser parser = {"O:__mypyc_singledispatch_main_function_is_empty_name__", kwlist, 0}; + PyObject *obj_name; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_name)) { + return NULL; + } + PyObject *arg_name; + if (PyUnicode_Check(obj_name)) + arg_name = obj_name; + else { + arg_name = NULL; + } + if (arg_name != NULL) goto __LL50; + if (obj_name == Py_None) + arg_name = obj_name; + else { + arg_name = NULL; + } + if (arg_name != NULL) goto __LL50; + CPy_TypeError("str or None", obj_name); + goto fail; +__LL50: ; + char retval = CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_is_empty_name__(arg_name); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_empty_name_obj_____init__(PyObject *cpy_r___mypyc_self__) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + int32_t cpy_r_r3; + char cpy_r_r4; + char cpy_r_r5; + cpy_r_r0 = PyDict_New(); + if (cpy_r_r0 == NULL) goto CPyL4; + ((faster_ens___utils___is_empty_name_objObject *)cpy_r___mypyc_self__)->_registry = cpy_r_r0; + cpy_r_r1 = PyDict_New(); + if (cpy_r_r1 == NULL) goto CPyL4; + cpy_r_r2 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'dispatch_cache' */ + cpy_r_r3 = PyObject_SetAttr(cpy_r___mypyc_self__, cpy_r_r2, cpy_r_r1); + CPy_DECREF(cpy_r_r1); + cpy_r_r4 = cpy_r_r3 >= 0; + if (!cpy_r_r4) goto CPyL4; + return 1; +CPyL4: ; + cpy_r_r5 = 2; + return cpy_r_r5; +} + +PyObject *CPyPy_faster_ens___utils___is_empty_name_obj_____init__(PyObject *self, PyObject *args, PyObject *kw) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {0}; + if (!CPyArg_ParseTupleAndKeywords(args, kw, "", "__init__", kwlist)) { + return NULL; + } + PyObject *arg___mypyc_self__; + if (likely(Py_TYPE(obj___mypyc_self__) == CPyType_faster_ens___utils___is_empty_name_obj)) + arg___mypyc_self__ = obj___mypyc_self__; + else { + CPy_TypeError("faster_ens.utils.is_empty_name_obj", obj___mypyc_self__); + goto fail; + } + char retval = CPyDef_faster_ens___utils___is_empty_name_obj_____init__(arg___mypyc_self__); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "__init__", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_empty_name_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_name) { + CPyPtr cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + PyObject *cpy_r_r3; + PyObject *cpy_r_r4; + char 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_r12; + PyObject *cpy_r_r13; + int32_t cpy_r_r14; + char cpy_r_r15; + PyObject *cpy_r_r16; + CPyPtr cpy_r_r17; + PyObject *cpy_r_r18; + char cpy_r_r19; + CPyTagged cpy_r_r20; + char cpy_r_r21; + PyObject *cpy_r_r22; + char cpy_r_r23; + PyObject **cpy_r_r25; + PyObject *cpy_r_r26; + char cpy_r_r27; + char cpy_r_r28; + cpy_r_r0 = (CPyPtr)&((PyObject *)cpy_r_name)->ob_type; + cpy_r_r1 = *(PyObject * *)cpy_r_r0; + cpy_r_r2 = ((faster_ens___utils___is_empty_name_objObject *)cpy_r___mypyc_self__)->_dispatch_cache; + if (unlikely(cpy_r_r2 == NULL)) { + CPy_AttributeError("faster_ens/utils.py", "is_empty_name", "is_empty_name_obj", "dispatch_cache", 310, CPyStatic_faster_ens___utils___globals); + goto CPyL18; + } + CPy_INCREF(cpy_r_r2); +CPyL1: ; + cpy_r_r3 = CPyDict_GetWithNone(cpy_r_r2, cpy_r_r1); + if (unlikely(cpy_r_r3 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL19; + } + cpy_r_r4 = (PyObject *)&_Py_NoneStruct; + cpy_r_r5 = cpy_r_r3 != cpy_r_r4; + if (cpy_r_r5) { + goto CPyL20; + } else + goto CPyL21; +CPyL3: ; + cpy_r_r6 = cpy_r_r3; + goto CPyL8; +CPyL4: ; + cpy_r_r7 = CPyModule_functools; + cpy_r_r8 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '_find_impl' */ + cpy_r_r9 = CPyObject_GetAttr(cpy_r_r7, cpy_r_r8); + if (unlikely(cpy_r_r9 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL19; + } + cpy_r_r10 = ((faster_ens___utils___is_empty_name_objObject *)cpy_r___mypyc_self__)->_registry; + CPy_INCREF(cpy_r_r10); + PyObject *cpy_r_r11[2] = {cpy_r_r1, cpy_r_r10}; + cpy_r_r12 = (PyObject **)&cpy_r_r11; + cpy_r_r13 = PyObject_Vectorcall(cpy_r_r9, cpy_r_r12, 2, 0); + CPy_DECREF(cpy_r_r9); + if (unlikely(cpy_r_r13 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL22; + } + CPy_DECREF(cpy_r_r10); + cpy_r_r14 = PyDict_SetItem(cpy_r_r2, cpy_r_r1, cpy_r_r13); + CPy_DECREF(cpy_r_r2); + cpy_r_r15 = cpy_r_r14 >= 0; + if (unlikely(!cpy_r_r15)) { + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL23; + } + cpy_r_r6 = cpy_r_r13; +CPyL8: ; + cpy_r_r16 = (PyObject *)&PyLong_Type; + cpy_r_r17 = (CPyPtr)&((PyObject *)cpy_r_r6)->ob_type; + cpy_r_r18 = *(PyObject * *)cpy_r_r17; + cpy_r_r19 = cpy_r_r18 == cpy_r_r16; + if (!cpy_r_r19) goto CPyL15; + if (likely(PyLong_Check(cpy_r_r6))) + cpy_r_r20 = CPyTagged_FromObject(cpy_r_r6); + else { + CPy_TypeError("int", cpy_r_r6); cpy_r_r20 = CPY_INT_TAG; + } + CPy_DECREF(cpy_r_r6); + if (unlikely(cpy_r_r20 == CPY_INT_TAG)) { + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL18; + } + cpy_r_r21 = cpy_r_r20 == 0; + CPyTagged_DECREF(cpy_r_r20); + if (!cpy_r_r21) goto CPyL14; + CPy_INCREF(cpy_r_name); + if (likely(cpy_r_name != Py_None)) + cpy_r_r22 = cpy_r_name; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "is_empty_name", 310, CPyStatic_faster_ens___utils___globals, "str", cpy_r_name); + goto CPyL18; + } + cpy_r_r23 = CPyDef_faster_ens___utils___is_empty_name_str(cpy_r_r22); + CPy_DECREF(cpy_r_r22); + if (unlikely(cpy_r_r23 == 2)) { + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL18; + } + return cpy_r_r23; +CPyL14: ; + CPy_Unreachable(); +CPyL15: ; + PyObject *cpy_r_r24[1] = {cpy_r_name}; + cpy_r_r25 = (PyObject **)&cpy_r_r24; + cpy_r_r26 = PyObject_Vectorcall(cpy_r_r6, cpy_r_r25, 1, 0); + CPy_DECREF(cpy_r_r6); + if (unlikely(cpy_r_r26 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL18; + } + if (unlikely(!PyBool_Check(cpy_r_r26))) { + CPy_TypeError("bool", cpy_r_r26); cpy_r_r27 = 2; + } else + cpy_r_r27 = cpy_r_r26 == Py_True; + CPy_DECREF(cpy_r_r26); + if (unlikely(cpy_r_r27 == 2)) { + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL18; + } + return cpy_r_r27; +CPyL18: ; + cpy_r_r28 = 2; + return cpy_r_r28; +CPyL19: ; + CPy_DecRef(cpy_r_r2); + goto CPyL18; +CPyL20: ; + CPy_DECREF(cpy_r_r2); + goto CPyL3; +CPyL21: ; + CPy_DECREF(cpy_r_r3); + goto CPyL4; +CPyL22: ; + CPy_DecRef(cpy_r_r2); + CPy_DecRef(cpy_r_r10); + goto CPyL18; +CPyL23: ; + CPy_DecRef(cpy_r_r13); + goto CPyL18; +} + +PyObject *CPyPy_faster_ens___utils___is_empty_name_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"name", 0}; + static CPyArg_Parser parser = {"O:__call__", kwlist, 0}; + PyObject *obj_name; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, PyVectorcall_NARGS(nargs), kwnames, &parser, &obj_name)) { + return NULL; + } + PyObject *arg___mypyc_self__ = obj___mypyc_self__; + PyObject *arg_name; + if (PyUnicode_Check(obj_name)) + arg_name = obj_name; + else { + arg_name = NULL; + } + if (arg_name != NULL) goto __LL51; + if (obj_name == Py_None) + arg_name = obj_name; + else { + arg_name = NULL; + } + if (arg_name != NULL) goto __LL51; + CPy_TypeError("str or None", obj_name); + goto fail; +__LL51: ; + char retval = CPyDef_faster_ens___utils___is_empty_name_obj_____call__(arg___mypyc_self__, arg_name); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___is_empty_name_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_faster_ens___utils___is_empty_name_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_faster_ens___utils___is_empty_name_obj_____get__(arg___mypyc_self__, arg_instance, arg_owner); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "__get__", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +PyObject *CPyDef_faster_ens___utils___is_empty_name_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + cpy_r_r0 = CPySingledispatch_RegisterFunction(cpy_r___mypyc_self__, cpy_r_cls, cpy_r_func); + if (cpy_r_r0 == NULL) goto CPyL2; + return cpy_r_r0; +CPyL2: ; + cpy_r_r1 = NULL; + return cpy_r_r1; +} + +PyObject *CPyPy_faster_ens___utils___is_empty_name_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + PyObject *obj___mypyc_self__ = self; + static const char * const kwlist[] = {"cls", "func", 0}; + static CPyArg_Parser parser = {"O|O:register", kwlist, 0}; + PyObject *obj_cls; + PyObject *obj_func = NULL; + if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_cls, &obj_func)) { + return NULL; + } + PyObject *arg___mypyc_self__; + if (likely(Py_TYPE(obj___mypyc_self__) == CPyType_faster_ens___utils___is_empty_name_obj)) + arg___mypyc_self__ = obj___mypyc_self__; + else { + CPy_TypeError("faster_ens.utils.is_empty_name_obj", obj___mypyc_self__); + goto fail; + } + PyObject *arg_cls = obj_cls; + PyObject *arg_func; + if (obj_func == NULL) { + arg_func = NULL; + } else { + arg_func = obj_func; + } + PyObject *retval = CPyDef_faster_ens___utils___is_empty_name_obj___register(arg___mypyc_self__, arg_cls, arg_func); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "register", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_empty_name(PyObject *cpy_r_name) { + PyObject *cpy_r_r0; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + char cpy_r_r3; + char cpy_r_r4; + cpy_r_r0 = CPyStatic_faster_ens___utils___globals; + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_empty_name' */ + cpy_r_r2 = CPyDict_GetItem(cpy_r_r0, cpy_r_r1); + if (cpy_r_r2 == NULL) goto CPyL3; + cpy_r_r3 = CPyDef_faster_ens___utils___is_empty_name_obj_____call__(cpy_r_r2, cpy_r_name); + CPy_DECREF(cpy_r_r2); + if (cpy_r_r3 == 2) goto CPyL3; + return cpy_r_r3; +CPyL3: ; + cpy_r_r4 = 2; + return cpy_r_r4; +} + +PyObject *CPyPy_faster_ens___utils___is_empty_name(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"name", 0}; + static CPyArg_Parser parser = {"O:is_empty_name", kwlist, 0}; + PyObject *obj_name; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_name)) { + return NULL; + } + PyObject *arg_name; + if (PyUnicode_Check(obj_name)) + arg_name = obj_name; + else { + arg_name = NULL; + } + if (arg_name != NULL) goto __LL52; + if (obj_name == Py_None) + arg_name = obj_name; + else { + arg_name = NULL; + } + if (arg_name != NULL) goto __LL52; + CPy_TypeError("str or None", obj_name); + goto fail; +__LL52: ; + char retval = CPyDef_faster_ens___utils___is_empty_name(arg_name); + if (retval == 2) { + return NULL; + } + PyObject *retbox = retval ? Py_True : Py_False; + CPy_INCREF(retbox); + return retbox; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", -1, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___utils___is_empty_name_none(char cpy_r_name) { + return 1; +} + +PyObject *CPyPy_faster_ens___utils___is_empty_name_none(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { + static const char * const kwlist[] = {"name", 0}; + static CPyArg_Parser parser = {"O:is_empty_name_none", kwlist, 0}; + PyObject *obj_name; + if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_name)) { + return NULL; + } + char arg_name; + if (unlikely(obj_name != Py_None)) { + CPy_TypeError("None", obj_name); goto fail; + } else + arg_name = 1; + char retval = CPyDef_faster_ens___utils___is_empty_name_none(arg_name); if (retval == 2) { return NULL; } @@ -16114,50 +18379,39 @@ __LL45: ; CPy_INCREF(retbox); return retbox; fail: ; - CPy_AddTraceback("faster_ens/utils.py", "is_none_or_zero_address", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name_none", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); return NULL; } -char CPyDef_faster_ens___utils___is_empty_name(PyObject *cpy_r_name) { +char CPyDef_faster_ens___utils___is_empty_name_str(PyObject *cpy_r_name) { PyObject *cpy_r_r0; - char cpy_r_r1; - char cpy_r_r2; - PyObject *cpy_r_r3; - PyObject *cpy_r_r4; - PyObject *cpy_r_r5; - char cpy_r_r6; - char cpy_r_r7; - char cpy_r_r8; - cpy_r_r0 = (PyObject *)&_Py_NoneStruct; - cpy_r_r1 = cpy_r_name == cpy_r_r0; - if (!cpy_r_r1) goto CPyL2; - cpy_r_r2 = cpy_r_r1; - goto CPyL7; -CPyL2: ; - cpy_r_r3 = CPyStr_Strip(cpy_r_name, 0); - cpy_r_r4 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ - cpy_r_r5 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '.' */ - cpy_r_r6 = CPyStr_Equal(cpy_r_r3, cpy_r_r4); - if (cpy_r_r6) goto CPyL8; - cpy_r_r7 = CPyStr_Equal(cpy_r_r3, cpy_r_r5); - CPy_DECREF(cpy_r_r3); - if (cpy_r_r7) goto CPyL5; - cpy_r_r8 = 0; - goto CPyL6; + PyObject *cpy_r_r1; + PyObject *cpy_r_r2; + char cpy_r_r3; + char cpy_r_r4; + char cpy_r_r5; + cpy_r_r0 = CPyStr_Strip(cpy_r_name, 0); + cpy_r_r1 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ + cpy_r_r2 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '.' */ + cpy_r_r3 = CPyStr_Equal(cpy_r_r0, cpy_r_r1); + if (cpy_r_r3) goto CPyL5; + cpy_r_r4 = CPyStr_Equal(cpy_r_r0, cpy_r_r2); + CPy_DECREF(cpy_r_r0); + if (cpy_r_r4) goto CPyL3; + cpy_r_r5 = 0; + goto CPyL4; +CPyL3: ; + cpy_r_r5 = 1; +CPyL4: ; + return cpy_r_r5; CPyL5: ; - cpy_r_r8 = 1; -CPyL6: ; - cpy_r_r2 = cpy_r_r8; -CPyL7: ; - return cpy_r_r2; -CPyL8: ; - CPy_DECREF(cpy_r_r3); - goto CPyL5; + CPy_DECREF(cpy_r_r0); + goto CPyL3; } -PyObject *CPyPy_faster_ens___utils___is_empty_name(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { +PyObject *CPyPy_faster_ens___utils___is_empty_name_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames) { static const char * const kwlist[] = {"name", 0}; - static CPyArg_Parser parser = {"O:is_empty_name", kwlist, 0}; + static CPyArg_Parser parser = {"O:is_empty_name_str", kwlist, 0}; PyObject *obj_name; if (!CPyArg_ParseStackAndKeywordsOneArg(args, nargs, kwnames, &parser, &obj_name)) { return NULL; @@ -16169,7 +18423,7 @@ PyObject *CPyPy_faster_ens___utils___is_empty_name(PyObject *self, PyObject *con CPy_TypeError("str", obj_name); goto fail; } - char retval = CPyDef_faster_ens___utils___is_empty_name(arg_name); + char retval = CPyDef_faster_ens___utils___is_empty_name_str(arg_name); if (retval == 2) { return NULL; } @@ -16177,7 +18431,7 @@ PyObject *CPyPy_faster_ens___utils___is_empty_name(PyObject *self, PyObject *con CPy_INCREF(retbox); return retbox; fail: ; - CPy_AddTraceback("faster_ens/utils.py", "is_empty_name", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + CPy_AddTraceback("faster_ens/utils.py", "is_empty_name_str", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); return NULL; } @@ -16476,7 +18730,7 @@ CPyL4: ; if (likely(PyList_Check(cpy_r_middleware))) cpy_r_r19 = cpy_r_middleware; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 312, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); + CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 347, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); goto CPyL47; } cpy_r_r20 = 0; @@ -16492,39 +18746,39 @@ CPyL10: ; cpy_r_r27 = cpy_r_r25 + cpy_r_r26; cpy_r_r28 = *(PyObject * *)cpy_r_r27; CPy_INCREF(cpy_r_r28); - PyObject *__tmp46; + PyObject *__tmp53; if (unlikely(!(PyTuple_Check(cpy_r_r28) && PyTuple_GET_SIZE(cpy_r_r28) == 2))) { - __tmp46 = NULL; - goto __LL47; + __tmp53 = NULL; + goto __LL54; } - __tmp46 = PyTuple_GET_ITEM(cpy_r_r28, 0); - if (__tmp46 == NULL) goto __LL47; + __tmp53 = PyTuple_GET_ITEM(cpy_r_r28, 0); + if (__tmp53 == NULL) goto __LL54; if (likely(PyUnicode_Check(PyTuple_GET_ITEM(cpy_r_r28, 1)))) - __tmp46 = PyTuple_GET_ITEM(cpy_r_r28, 1); + __tmp53 = PyTuple_GET_ITEM(cpy_r_r28, 1); else { - __tmp46 = NULL; + __tmp53 = NULL; } - if (__tmp46 == NULL) goto __LL47; - __tmp46 = cpy_r_r28; -__LL47: ; - if (unlikely(__tmp46 == NULL)) { + if (__tmp53 == NULL) goto __LL54; + __tmp53 = cpy_r_r28; +__LL54: ; + if (unlikely(__tmp53 == NULL)) { CPy_TypeError("tuple[object, str]", cpy_r_r28); cpy_r_r29 = (tuple_T2OO) { NULL, NULL }; } else { - PyObject *__tmp48 = PyTuple_GET_ITEM(cpy_r_r28, 0); - CPy_INCREF(__tmp48); - PyObject *__tmp49; - __tmp49 = __tmp48; - cpy_r_r29.f0 = __tmp49; - PyObject *__tmp50 = PyTuple_GET_ITEM(cpy_r_r28, 1); - CPy_INCREF(__tmp50); - PyObject *__tmp51; - if (likely(PyUnicode_Check(__tmp50))) - __tmp51 = __tmp50; + PyObject *__tmp55 = PyTuple_GET_ITEM(cpy_r_r28, 0); + CPy_INCREF(__tmp55); + PyObject *__tmp56; + __tmp56 = __tmp55; + cpy_r_r29.f0 = __tmp56; + PyObject *__tmp57 = PyTuple_GET_ITEM(cpy_r_r28, 1); + CPy_INCREF(__tmp57); + PyObject *__tmp58; + if (likely(PyUnicode_Check(__tmp57))) + __tmp58 = __tmp57; else { - CPy_TypeError("str", __tmp50); - __tmp51 = NULL; + CPy_TypeError("str", __tmp57); + __tmp58 = NULL; } - cpy_r_r29.f1 = __tmp51; + cpy_r_r29.f1 = __tmp58; } CPy_DECREF(cpy_r_r28); if (unlikely(cpy_r_r29.f0 == NULL)) { @@ -16546,7 +18800,7 @@ __LL47: ; if (likely(PyList_Check(cpy_r_middleware))) cpy_r_r34 = cpy_r_middleware; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 314, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); + CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 349, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); goto CPyL50; } cpy_r_r35 = CPyList_Pop(cpy_r_r34, cpy_r_i); @@ -16556,39 +18810,39 @@ __LL47: ; CPy_AddTraceback("faster_ens/utils.py", "init_async_web3", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); goto CPyL52; } - PyObject *__tmp52; + PyObject *__tmp59; if (unlikely(!(PyTuple_Check(cpy_r_r35) && PyTuple_GET_SIZE(cpy_r_r35) == 2))) { - __tmp52 = NULL; - goto __LL53; + __tmp59 = NULL; + goto __LL60; } - __tmp52 = PyTuple_GET_ITEM(cpy_r_r35, 0); - if (__tmp52 == NULL) goto __LL53; + __tmp59 = PyTuple_GET_ITEM(cpy_r_r35, 0); + if (__tmp59 == NULL) goto __LL60; if (likely(PyUnicode_Check(PyTuple_GET_ITEM(cpy_r_r35, 1)))) - __tmp52 = PyTuple_GET_ITEM(cpy_r_r35, 1); + __tmp59 = PyTuple_GET_ITEM(cpy_r_r35, 1); else { - __tmp52 = NULL; + __tmp59 = NULL; } - if (__tmp52 == NULL) goto __LL53; - __tmp52 = cpy_r_r35; -__LL53: ; - if (unlikely(__tmp52 == NULL)) { + if (__tmp59 == NULL) goto __LL60; + __tmp59 = cpy_r_r35; +__LL60: ; + if (unlikely(__tmp59 == NULL)) { CPy_TypeError("tuple[object, str]", cpy_r_r35); cpy_r_r36 = (tuple_T2OO) { NULL, NULL }; } else { - PyObject *__tmp54 = PyTuple_GET_ITEM(cpy_r_r35, 0); - CPy_INCREF(__tmp54); - PyObject *__tmp55; - __tmp55 = __tmp54; - cpy_r_r36.f0 = __tmp55; - PyObject *__tmp56 = PyTuple_GET_ITEM(cpy_r_r35, 1); - CPy_INCREF(__tmp56); - PyObject *__tmp57; - if (likely(PyUnicode_Check(__tmp56))) - __tmp57 = __tmp56; + PyObject *__tmp61 = PyTuple_GET_ITEM(cpy_r_r35, 0); + CPy_INCREF(__tmp61); + PyObject *__tmp62; + __tmp62 = __tmp61; + cpy_r_r36.f0 = __tmp62; + PyObject *__tmp63 = PyTuple_GET_ITEM(cpy_r_r35, 1); + CPy_INCREF(__tmp63); + PyObject *__tmp64; + if (likely(PyUnicode_Check(__tmp63))) + __tmp64 = __tmp63; else { - CPy_TypeError("str", __tmp56); - __tmp57 = NULL; + CPy_TypeError("str", __tmp63); + __tmp64 = NULL; } - cpy_r_r36.f1 = __tmp57; + cpy_r_r36.f1 = __tmp64; } CPy_DECREF(cpy_r_r35); if (unlikely(cpy_r_r36.f0 == NULL)) { @@ -16608,7 +18862,7 @@ CPyL17: ; if (likely(PyList_Check(cpy_r_middleware))) cpy_r_r40 = cpy_r_middleware; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 316, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); + CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 351, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); goto CPyL47; } cpy_r_r41 = (CPyPtr)&((PyVarObject *)cpy_r_r40)->ob_size; @@ -16630,39 +18884,39 @@ CPyL20: ; cpy_r_r51 = cpy_r_r49 + cpy_r_r50; cpy_r_r52 = *(PyObject * *)cpy_r_r51; CPy_INCREF(cpy_r_r52); - PyObject *__tmp58; + PyObject *__tmp65; if (unlikely(!(PyTuple_Check(cpy_r_r52) && PyTuple_GET_SIZE(cpy_r_r52) == 2))) { - __tmp58 = NULL; - goto __LL59; + __tmp65 = NULL; + goto __LL66; } - __tmp58 = PyTuple_GET_ITEM(cpy_r_r52, 0); - if (__tmp58 == NULL) goto __LL59; + __tmp65 = PyTuple_GET_ITEM(cpy_r_r52, 0); + if (__tmp65 == NULL) goto __LL66; if (likely(PyUnicode_Check(PyTuple_GET_ITEM(cpy_r_r52, 1)))) - __tmp58 = PyTuple_GET_ITEM(cpy_r_r52, 1); + __tmp65 = PyTuple_GET_ITEM(cpy_r_r52, 1); else { - __tmp58 = NULL; + __tmp65 = NULL; } - if (__tmp58 == NULL) goto __LL59; - __tmp58 = cpy_r_r52; -__LL59: ; - if (unlikely(__tmp58 == NULL)) { + if (__tmp65 == NULL) goto __LL66; + __tmp65 = cpy_r_r52; +__LL66: ; + if (unlikely(__tmp65 == NULL)) { CPy_TypeError("tuple[object, str]", cpy_r_r52); cpy_r_r53 = (tuple_T2OO) { NULL, NULL }; } else { - PyObject *__tmp60 = PyTuple_GET_ITEM(cpy_r_r52, 0); - CPy_INCREF(__tmp60); - PyObject *__tmp61; - __tmp61 = __tmp60; - cpy_r_r53.f0 = __tmp61; - PyObject *__tmp62 = PyTuple_GET_ITEM(cpy_r_r52, 1); - CPy_INCREF(__tmp62); - PyObject *__tmp63; - if (likely(PyUnicode_Check(__tmp62))) - __tmp63 = __tmp62; + PyObject *__tmp67 = PyTuple_GET_ITEM(cpy_r_r52, 0); + CPy_INCREF(__tmp67); + PyObject *__tmp68; + __tmp68 = __tmp67; + cpy_r_r53.f0 = __tmp68; + PyObject *__tmp69 = PyTuple_GET_ITEM(cpy_r_r52, 1); + CPy_INCREF(__tmp69); + PyObject *__tmp70; + if (likely(PyUnicode_Check(__tmp69))) + __tmp70 = __tmp69; else { - CPy_TypeError("str", __tmp62); - __tmp63 = NULL; + CPy_TypeError("str", __tmp69); + __tmp70 = NULL; } - cpy_r_r53.f1 = __tmp63; + cpy_r_r53.f1 = __tmp70; } CPy_DECREF(cpy_r_r52); if (unlikely(cpy_r_r53.f0 == NULL)) { @@ -16701,7 +18955,7 @@ CPyL24: ; if (likely(PyList_Check(cpy_r_middleware))) cpy_r_r62 = cpy_r_middleware; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 317, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); + CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 352, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); goto CPyL47; } cpy_r_r63 = CPyStatic_faster_ens___utils___globals; @@ -16728,10 +18982,10 @@ CPyL24: ; cpy_r_r73 = PyTuple_New(2); if (unlikely(cpy_r_r73 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp64 = cpy_r_r72.f0; - PyTuple_SET_ITEM(cpy_r_r73, 0, __tmp64); - PyObject *__tmp65 = cpy_r_r72.f1; - PyTuple_SET_ITEM(cpy_r_r73, 1, __tmp65); + PyObject *__tmp71 = cpy_r_r72.f0; + PyTuple_SET_ITEM(cpy_r_r73, 0, __tmp71); + PyObject *__tmp72 = cpy_r_r72.f1; + PyTuple_SET_ITEM(cpy_r_r73, 1, __tmp72); cpy_r_r74 = PyList_Append(cpy_r_r62, cpy_r_r73); CPy_DECREF_NO_IMM(cpy_r_r62); CPy_DECREF(cpy_r_r73); @@ -16751,7 +19005,7 @@ CPyL32: ; if (likely(PyList_Check(cpy_r_middleware))) cpy_r_r78 = cpy_r_middleware; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 326, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); + CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 361, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); goto CPyL44; } cpy_r_r79 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'eth' */ @@ -16792,7 +19046,7 @@ CPyL38: ; if (likely(PyList_Check(cpy_r_middleware))) cpy_r_r92 = cpy_r_middleware; else { - CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 331, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); + CPy_TypeErrorTraceback("faster_ens/utils.py", "init_async_web3", 366, CPyStatic_faster_ens___utils___globals, "list", cpy_r_middleware); goto CPyL48; } cpy_r_r93 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'eth' */ @@ -16921,243 +19175,983 @@ PyObject *CPyPy_faster_ens___utils___init_async_web3(PyObject *self, PyObject *c if (!CPyArg_ParseStackAndKeywordsSimple(args, nargs, kwnames, &parser, &obj_provider, &obj_middleware)) { return NULL; } - PyObject *arg_provider; - if (obj_provider == NULL) { - arg_provider = NULL; - goto __LL66; + PyObject *arg_provider; + if (obj_provider == NULL) { + arg_provider = NULL; + goto __LL73; + } + arg_provider = obj_provider; + if (arg_provider != NULL) goto __LL73; + if (obj_provider == Py_None) + arg_provider = obj_provider; + else { + arg_provider = NULL; + } + if (arg_provider != NULL) goto __LL73; + CPy_TypeError("object or None", obj_provider); + goto fail; +__LL73: ; + PyObject *arg_middleware; + if (obj_middleware == NULL) { + arg_middleware = NULL; + goto __LL74; + } + arg_middleware = obj_middleware; + if (arg_middleware != NULL) goto __LL74; + if (obj_middleware == Py_None) + arg_middleware = obj_middleware; + else { + arg_middleware = NULL; + } + if (arg_middleware != NULL) goto __LL74; + CPy_TypeError("object or None", obj_middleware); + goto fail; +__LL74: ; + PyObject *retval = CPyDef_faster_ens___utils___init_async_web3(arg_provider, arg_middleware); + return retval; +fail: ; + CPy_AddTraceback("faster_ens/utils.py", "init_async_web3", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + return NULL; +} + +char CPyDef_faster_ens___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; + 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; + void *cpy_r_r19; + void *cpy_r_r21; + PyObject *cpy_r_r22; + PyObject *cpy_r_r23; + PyObject *cpy_r_r24; + PyObject *cpy_r_r25; + char 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; + PyObject *cpy_r_r44; + PyObject *cpy_r_r45; + PyObject *cpy_r_r46; + PyObject *cpy_r_r47; + PyObject *cpy_r_r48; + PyObject *cpy_r_r49; + PyObject *cpy_r_r50; + PyObject *cpy_r_r51; + PyObject *cpy_r_r52; + PyObject *cpy_r_r53; + PyObject *cpy_r_r54; + PyObject *cpy_r_r55; + PyObject *cpy_r_r56; + int32_t cpy_r_r57; + char cpy_r_r58; + PyObject *cpy_r_r59; + PyObject *cpy_r_sha3_text; + PyObject *cpy_r_r60; + PyObject *cpy_r_r61; + int32_t cpy_r_r62; + char 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_r70; + PyObject *cpy_r_r71; + PyObject *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; + PyObject *cpy_r_r79; + PyObject *cpy_r_r80; + PyObject *cpy_r_r81; + PyObject *cpy_r_r82; + PyObject *cpy_r_r83; + PyObject *cpy_r_r84; + int32_t cpy_r_r85; + char cpy_r_r86; + PyObject *cpy_r_r87; + PyObject *cpy_r_r88; + PyObject *cpy_r_r89; + PyObject **cpy_r_r91; + PyObject *cpy_r_r92; + PyObject *cpy_r_r93; + PyObject *cpy_r_r94; + PyObject *cpy_r_r95; + PyObject *cpy_r_r96; + PyObject *cpy_r_r97; + PyObject *cpy_r_r98; + PyObject *cpy_r_r99; + PyObject *cpy_r_r100; + int32_t cpy_r_r101; + char cpy_r_r102; + PyObject *cpy_r_r103; + PyObject *cpy_r_r104; + PyObject *cpy_r_r105; + PyObject **cpy_r_r107; + PyObject *cpy_r_r108; + PyObject *cpy_r_r109; + PyObject *cpy_r_is_none_or_zero_address; + PyObject *cpy_r_r110; + PyObject *cpy_r_r111; + int32_t cpy_r_r112; + char cpy_r_r113; + PyObject *cpy_r_r114; + 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_r122; + PyObject *cpy_r_r123; + PyObject *cpy_r_r124; + int32_t cpy_r_r125; + char cpy_r_r126; + PyObject *cpy_r_r127; + PyObject *cpy_r_r128; + PyObject *cpy_r_r129; + PyObject *cpy_r_r130; + PyObject *cpy_r_r131; + PyObject *cpy_r_r132; + PyObject *cpy_r_r133; + PyObject *cpy_r_r134; + PyObject *cpy_r_r135; + PyObject **cpy_r_r137; + PyObject *cpy_r_r138; + PyObject **cpy_r_r140; + PyObject *cpy_r_r141; + PyObject *cpy_r_r142; + PyObject *cpy_r_r143; + int32_t cpy_r_r144; + char cpy_r_r145; + 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; + PyObject *cpy_r_r158; + PyObject **cpy_r_r160; + PyObject *cpy_r_r161; + PyObject *cpy_r_r162; + PyObject *cpy_r_r163; + PyObject *cpy_r_r164; + PyObject *cpy_r_r165; + PyObject *cpy_r_r166; + PyObject *cpy_r_r167; + PyObject *cpy_r_r168; + PyObject *cpy_r_r169; + int32_t cpy_r_r170; + char cpy_r_r171; + 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_is_empty_name; + PyObject *cpy_r_r179; + PyObject *cpy_r_r180; + int32_t cpy_r_r181; + char 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; + PyObject *cpy_r_r190; + PyObject *cpy_r_r191; + PyObject *cpy_r_r192; + PyObject *cpy_r_r193; + int32_t cpy_r_r194; + char 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; + PyObject *cpy_r_r203; + PyObject *cpy_r_r204; + PyObject **cpy_r_r206; + PyObject *cpy_r_r207; + PyObject **cpy_r_r209; + PyObject *cpy_r_r210; + PyObject *cpy_r_r211; + PyObject *cpy_r_r212; + int32_t cpy_r_r213; + char 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_r220; + PyObject *cpy_r_r221; + PyObject *cpy_r_r222; + int32_t cpy_r_r223; + char cpy_r_r224; + PyObject *cpy_r_r225; + PyObject *cpy_r_r226; + PyObject *cpy_r_r227; + PyObject **cpy_r_r229; + PyObject *cpy_r_r230; + char cpy_r_r231; + cpy_r_r0 = CPyModule_builtins; + cpy_r_r1 = (PyObject *)&_Py_NoneStruct; + cpy_r_r2 = cpy_r_r0 != cpy_r_r1; + if (cpy_r_r2) goto CPyL3; + cpy_r_r3 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'builtins' */ + cpy_r_r4 = PyImport_Import(cpy_r_r3); + if (unlikely(cpy_r_r4 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", -1, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_builtins = cpy_r_r4; + CPy_INCREF(CPyModule_builtins); + CPy_DECREF(cpy_r_r4); +CPyL3: ; + cpy_r_r5 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('datetime', 'timezone') */ + cpy_r_r6 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'datetime' */ + cpy_r_r7 = CPyStatic_faster_ens___utils___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_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_datetime = cpy_r_r8; + CPy_INCREF(CPyModule_datetime); + CPy_DECREF(cpy_r_r8); + cpy_r_r9 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('singledispatch',) */ + cpy_r_r10 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'functools' */ + cpy_r_r11 = CPyStatic_faster_ens___utils___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_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_functools = cpy_r_r12; + CPy_INCREF(CPyModule_functools); + CPy_DECREF(cpy_r_r12); + cpy_r_r13 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('TYPE_CHECKING', 'Any', 'Collection', 'Literal', + 'Optional', 'Sequence', 'Tuple', 'Type', 'Union') */ + cpy_r_r14 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'typing' */ + cpy_r_r15 = CPyStatic_faster_ens___utils___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_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_typing = cpy_r_r16; + CPy_INCREF(CPyModule_typing); + CPy_DECREF(cpy_r_r16); + cpy_r_r17 = (PyObject **)&CPyModule_warnings; + PyObject **cpy_r_r18[1] = {cpy_r_r17}; + cpy_r_r19 = (void *)&cpy_r_r18; + int64_t cpy_r_r20[1] = {19}; + cpy_r_r21 = (void *)&cpy_r_r20; + cpy_r_r22 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* (('warnings', 'warnings', 'warnings'),) */ + cpy_r_r23 = CPyStatic_faster_ens___utils___globals; + cpy_r_r24 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_ens/utils.py' */ + cpy_r_r25 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ + cpy_r_r26 = CPyImport_ImportMany(cpy_r_r22, cpy_r_r19, cpy_r_r23, cpy_r_r24, cpy_r_r25, cpy_r_r21); + if (!cpy_r_r26) goto CPyL79; + cpy_r_r27 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('Address', 'ChecksumAddress', 'HexAddress', 'HexStr') */ + cpy_r_r28 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'eth_typing' */ + cpy_r_r29 = CPyStatic_faster_ens___utils___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_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_eth_typing = cpy_r_r30; + CPy_INCREF(CPyModule_eth_typing); + CPy_DECREF(cpy_r_r30); + cpy_r_r31 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('is_same_address', 'remove_0x_prefix', 'to_bytes', + 'to_normalized_address') */ + cpy_r_r32 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_eth_utils' */ + cpy_r_r33 = CPyStatic_faster_ens___utils___globals; + cpy_r_r34 = CPyImport_ImportFromMany(cpy_r_r32, cpy_r_r31, cpy_r_r31, cpy_r_r33); + if (unlikely(cpy_r_r34 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_faster_eth_utils = cpy_r_r34; + CPy_INCREF(CPyModule_faster_eth_utils); + CPy_DECREF(cpy_r_r34); + cpy_r_r35 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('HexBytes',) */ + cpy_r_r36 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes' */ + cpy_r_r37 = CPyStatic_faster_ens___utils___globals; + cpy_r_r38 = CPyImport_ImportFromMany(cpy_r_r36, cpy_r_r35, cpy_r_r35, cpy_r_r37); + if (unlikely(cpy_r_r38 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_faster_hexbytes = cpy_r_r38; + CPy_INCREF(CPyModule_faster_hexbytes); + CPy_DECREF(cpy_r_r38); + cpy_r_r39 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('ENSTypeError', 'ENSValueError') */ + cpy_r_r40 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_ens.exceptions' */ + cpy_r_r41 = CPyStatic_faster_ens___utils___globals; + cpy_r_r42 = CPyImport_ImportFromMany(cpy_r_r40, cpy_r_r39, cpy_r_r39, cpy_r_r41); + if (unlikely(cpy_r_r42 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_faster_ens___exceptions = cpy_r_r42; + CPy_INCREF(CPyModule_faster_ens___exceptions); + CPy_DECREF(cpy_r_r42); + cpy_r_r43 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('ACCEPTABLE_STALE_HOURS', 'AUCTION_START_GAS_CONSTANT', + 'AUCTION_START_GAS_MARGINAL', 'EMPTY_ADDR_HEX', + 'EMPTY_SHA3_BYTES', 'REVERSE_REGISTRAR_DOMAIN') */ + cpy_r_r44 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_ens.constants' */ + cpy_r_r45 = CPyStatic_faster_ens___utils___globals; + cpy_r_r46 = CPyImport_ImportFromMany(cpy_r_r44, cpy_r_r43, cpy_r_r43, cpy_r_r45); + if (unlikely(cpy_r_r46 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_faster_ens___constants = cpy_r_r46; + CPy_INCREF(CPyModule_faster_ens___constants); + CPy_DECREF(cpy_r_r46); + cpy_r_r47 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('ENSValidationError', 'InvalidName') */ + cpy_r_r48 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_ens.exceptions' */ + cpy_r_r49 = CPyStatic_faster_ens___utils___globals; + cpy_r_r50 = CPyImport_ImportFromMany(cpy_r_r48, cpy_r_r47, cpy_r_r47, cpy_r_r49); + if (unlikely(cpy_r_r50 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPyModule_faster_ens___exceptions = cpy_r_r50; + CPy_INCREF(CPyModule_faster_ens___exceptions); + CPy_DECREF(cpy_r_r50); + cpy_r_r51 = CPyModule_builtins; + cpy_r_r52 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'object' */ + cpy_r_r53 = CPyObject_GetAttr(cpy_r_r51, cpy_r_r52); + if (unlikely(cpy_r_r53 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r54 = PyObject_Vectorcall(cpy_r_r53, 0, 0, 0); + CPy_DECREF(cpy_r_r53); + if (unlikely(cpy_r_r54 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r55 = CPyStatic_faster_ens___utils___globals; + cpy_r_r56 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'default' */ + cpy_r_r57 = CPyDict_SetItem(cpy_r_r55, cpy_r_r56, cpy_r_r54); + CPy_DECREF(cpy_r_r54); + cpy_r_r58 = cpy_r_r57 >= 0; + if (unlikely(!cpy_r_r58)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r59 = CPyDef_faster_ens___utils___sha3_text_obj(); + if (unlikely(cpy_r_r59 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPy_INCREF_NO_IMM(cpy_r_r59); + cpy_r_sha3_text = cpy_r_r59; + CPy_DECREF(cpy_r_sha3_text); + cpy_r_r60 = CPyStatic_faster_ens___utils___globals; + cpy_r_r61 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'sha3_text' */ + cpy_r_r62 = PyDict_SetItem(cpy_r_r60, cpy_r_r61, cpy_r_r59); + CPy_DECREF_NO_IMM(cpy_r_r59); + cpy_r_r63 = cpy_r_r62 >= 0; + if (unlikely(!cpy_r_r63)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r64 = CPyStatic_faster_ens___utils___globals; + cpy_r_r65 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__mypyc_singledispatch_main_function_sha3_text__' */ + cpy_r_r66 = CPyDict_GetItem(cpy_r_r64, cpy_r_r65); + if (unlikely(cpy_r_r66 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r67 = CPyModule_builtins; + cpy_r_r68 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'object' */ + cpy_r_r69 = CPyObject_GetAttr(cpy_r_r67, cpy_r_r68); + if (unlikely(cpy_r_r69 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL80; + } + cpy_r_r70 = CPyDict_Build(1, cpy_r_r69, cpy_r_r66); + CPy_DECREF(cpy_r_r69); + CPy_DECREF(cpy_r_r66); + if (unlikely(cpy_r_r70 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r71 = CPyStatic_faster_ens___utils___globals; + cpy_r_r72 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'sha3_text' */ + cpy_r_r73 = CPyDict_GetItem(cpy_r_r71, cpy_r_r72); + if (unlikely(cpy_r_r73 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL81; + } + cpy_r_r74 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'registry' */ + cpy_r_r75 = PyObject_SetAttr(cpy_r_r73, cpy_r_r74, cpy_r_r70); + CPy_DECREF(cpy_r_r73); + CPy_DECREF(cpy_r_r70); + cpy_r_r76 = cpy_r_r75 >= 0; + if (unlikely(!cpy_r_r76)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r77 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 0 */ + cpy_r_r78 = CPyStatic_faster_ens___utils___globals; + cpy_r_r79 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'sha3_text' */ + cpy_r_r80 = CPyDict_GetItem(cpy_r_r78, cpy_r_r79); + if (unlikely(cpy_r_r80 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r81 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'registry' */ + cpy_r_r82 = CPyObject_GetAttr(cpy_r_r80, cpy_r_r81); + if (unlikely(cpy_r_r82 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL82; + } + cpy_r_r83 = (PyObject *)&PyUnicode_Type; + if (likely(PyDict_Check(cpy_r_r82))) + cpy_r_r84 = cpy_r_r82; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "", 211, CPyStatic_faster_ens___utils___globals, "dict", cpy_r_r82); + goto CPyL82; + } + cpy_r_r85 = PyDict_SetItem(cpy_r_r84, cpy_r_r83, cpy_r_r77); + CPy_DECREF(cpy_r_r84); + cpy_r_r86 = cpy_r_r85 >= 0; + if (unlikely(!cpy_r_r86)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL82; + } + cpy_r_r87 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'dispatch_cache' */ + cpy_r_r88 = CPyObject_GetAttr(cpy_r_r80, cpy_r_r87); + CPy_DECREF(cpy_r_r80); + if (unlikely(cpy_r_r88 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r89 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'clear' */ + PyObject *cpy_r_r90[1] = {cpy_r_r88}; + cpy_r_r91 = (PyObject **)&cpy_r_r90; + cpy_r_r92 = PyObject_VectorcallMethod(cpy_r_r89, cpy_r_r91, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r92 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL83; + } else + goto CPyL84; +CPyL30: ; + CPy_DECREF(cpy_r_r88); + cpy_r_r93 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 1 */ + cpy_r_r94 = CPyStatic_faster_ens___utils___globals; + cpy_r_r95 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'sha3_text' */ + cpy_r_r96 = CPyDict_GetItem(cpy_r_r94, cpy_r_r95); + if (unlikely(cpy_r_r96 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r97 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'registry' */ + cpy_r_r98 = CPyObject_GetAttr(cpy_r_r96, cpy_r_r97); + if (unlikely(cpy_r_r98 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL85; + } + cpy_r_r99 = (PyObject *)&PyBytes_Type; + if (likely(PyDict_Check(cpy_r_r98))) + cpy_r_r100 = cpy_r_r98; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "", 215, CPyStatic_faster_ens___utils___globals, "dict", cpy_r_r98); + goto CPyL85; + } + cpy_r_r101 = PyDict_SetItem(cpy_r_r100, cpy_r_r99, cpy_r_r93); + CPy_DECREF(cpy_r_r100); + cpy_r_r102 = cpy_r_r101 >= 0; + if (unlikely(!cpy_r_r102)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL85; + } + cpy_r_r103 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'dispatch_cache' */ + cpy_r_r104 = CPyObject_GetAttr(cpy_r_r96, cpy_r_r103); + CPy_DECREF(cpy_r_r96); + if (unlikely(cpy_r_r104 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r105 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'clear' */ + PyObject *cpy_r_r106[1] = {cpy_r_r104}; + cpy_r_r107 = (PyObject **)&cpy_r_r106; + cpy_r_r108 = PyObject_VectorcallMethod(cpy_r_r105, cpy_r_r107, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r108 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL86; + } else + goto CPyL87; +CPyL36: ; + CPy_DECREF(cpy_r_r104); + cpy_r_r109 = CPyDef_faster_ens___utils___is_none_or_zero_address_obj(); + if (unlikely(cpy_r_r109 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + CPy_INCREF_NO_IMM(cpy_r_r109); + cpy_r_is_none_or_zero_address = cpy_r_r109; + CPy_DECREF(cpy_r_is_none_or_zero_address); + cpy_r_r110 = CPyStatic_faster_ens___utils___globals; + cpy_r_r111 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_none_or_zero_address' */ + cpy_r_r112 = PyDict_SetItem(cpy_r_r110, cpy_r_r111, cpy_r_r109); + CPy_DECREF_NO_IMM(cpy_r_r109); + cpy_r_r113 = cpy_r_r112 >= 0; + if (unlikely(!cpy_r_r113)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; } - arg_provider = obj_provider; - if (arg_provider != NULL) goto __LL66; - if (obj_provider == Py_None) - arg_provider = obj_provider; + cpy_r_r114 = CPyStatic_faster_ens___utils___globals; + cpy_r_r115 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__mypyc_singledispatch_main_function_is_none_or_zero_address__' */ + cpy_r_r116 = CPyDict_GetItem(cpy_r_r114, cpy_r_r115); + if (unlikely(cpy_r_r116 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r117 = CPyModule_builtins; + cpy_r_r118 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'object' */ + cpy_r_r119 = CPyObject_GetAttr(cpy_r_r117, cpy_r_r118); + if (unlikely(cpy_r_r119 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL88; + } + cpy_r_r120 = CPyDict_Build(1, cpy_r_r119, cpy_r_r116); + CPy_DECREF(cpy_r_r119); + CPy_DECREF(cpy_r_r116); + if (unlikely(cpy_r_r120 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r121 = CPyStatic_faster_ens___utils___globals; + cpy_r_r122 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_none_or_zero_address' */ + cpy_r_r123 = CPyDict_GetItem(cpy_r_r121, cpy_r_r122); + if (unlikely(cpy_r_r123 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL89; + } + cpy_r_r124 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'registry' */ + cpy_r_r125 = PyObject_SetAttr(cpy_r_r123, cpy_r_r124, cpy_r_r120); + CPy_DECREF(cpy_r_r123); + CPy_DECREF(cpy_r_r120); + cpy_r_r126 = cpy_r_r125 >= 0; + if (unlikely(!cpy_r_r126)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r127 = CPyStatic_faster_ens___utils___globals; + cpy_r_r128 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_none_or_zero_address_none' */ + cpy_r_r129 = CPyDict_GetItem(cpy_r_r127, cpy_r_r128); + if (unlikely(cpy_r_r129 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r130 = CPyStatic_faster_ens___utils___globals; + cpy_r_r131 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_none_or_zero_address' */ + cpy_r_r132 = CPyDict_GetItem(cpy_r_r130, cpy_r_r131); + if (unlikely(cpy_r_r132 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL90; + } + cpy_r_r133 = Py_None; + cpy_r_r134 = CPy_TYPE(cpy_r_r133); + cpy_r_r135 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'register' */ + PyObject *cpy_r_r136[2] = {cpy_r_r132, cpy_r_r134}; + cpy_r_r137 = (PyObject **)&cpy_r_r136; + cpy_r_r138 = PyObject_VectorcallMethod(cpy_r_r135, cpy_r_r137, 9223372036854775810ULL, 0); + if (unlikely(cpy_r_r138 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL91; + } + CPy_DECREF(cpy_r_r132); + CPy_DECREF(cpy_r_r134); + PyObject *cpy_r_r139[1] = {cpy_r_r129}; + cpy_r_r140 = (PyObject **)&cpy_r_r139; + cpy_r_r141 = PyObject_Vectorcall(cpy_r_r138, cpy_r_r140, 1, 0); + CPy_DECREF(cpy_r_r138); + if (unlikely(cpy_r_r141 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL90; + } + CPy_DECREF(cpy_r_r129); + cpy_r_r142 = CPyStatic_faster_ens___utils___globals; + cpy_r_r143 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_none_or_zero_address_none' */ + cpy_r_r144 = PyDict_SetItem(cpy_r_r142, cpy_r_r143, cpy_r_r141); + CPy_DECREF(cpy_r_r141); + cpy_r_r145 = cpy_r_r144 >= 0; + if (unlikely(!cpy_r_r145)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r146 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 0 */ + cpy_r_r147 = CPyStatic_faster_ens___utils___globals; + cpy_r_r148 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_none_or_zero_address' */ + cpy_r_r149 = CPyDict_GetItem(cpy_r_r147, cpy_r_r148); + if (unlikely(cpy_r_r149 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r150 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'registry' */ + cpy_r_r151 = CPyObject_GetAttr(cpy_r_r149, cpy_r_r150); + if (unlikely(cpy_r_r151 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL92; + } + cpy_r_r152 = (PyObject *)&PyUnicode_Type; + if (likely(PyDict_Check(cpy_r_r151))) + cpy_r_r153 = cpy_r_r151; else { - arg_provider = NULL; + CPy_TypeErrorTraceback("faster_ens/utils.py", "", 301, CPyStatic_faster_ens___utils___globals, "dict", cpy_r_r151); + goto CPyL92; } - if (arg_provider != NULL) goto __LL66; - CPy_TypeError("object or None", obj_provider); - goto fail; -__LL66: ; - PyObject *arg_middleware; - if (obj_middleware == NULL) { - arg_middleware = NULL; - goto __LL67; + cpy_r_r154 = PyDict_SetItem(cpy_r_r153, cpy_r_r152, cpy_r_r146); + CPy_DECREF(cpy_r_r153); + cpy_r_r155 = cpy_r_r154 >= 0; + if (unlikely(!cpy_r_r155)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL92; } - arg_middleware = obj_middleware; - if (arg_middleware != NULL) goto __LL67; - if (obj_middleware == Py_None) - arg_middleware = obj_middleware; + cpy_r_r156 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'dispatch_cache' */ + cpy_r_r157 = CPyObject_GetAttr(cpy_r_r149, cpy_r_r156); + CPy_DECREF(cpy_r_r149); + if (unlikely(cpy_r_r157 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r158 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'clear' */ + PyObject *cpy_r_r159[1] = {cpy_r_r157}; + cpy_r_r160 = (PyObject **)&cpy_r_r159; + cpy_r_r161 = PyObject_VectorcallMethod(cpy_r_r158, cpy_r_r160, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r161 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL93; + } else + goto CPyL94; +CPyL54: ; + CPy_DECREF(cpy_r_r157); + cpy_r_r162 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 1 */ + cpy_r_r163 = CPyStatic_faster_ens___utils___globals; + cpy_r_r164 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_none_or_zero_address' */ + cpy_r_r165 = CPyDict_GetItem(cpy_r_r163, cpy_r_r164); + if (unlikely(cpy_r_r165 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r166 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'registry' */ + cpy_r_r167 = CPyObject_GetAttr(cpy_r_r165, cpy_r_r166); + if (unlikely(cpy_r_r167 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL95; + } + cpy_r_r168 = (PyObject *)&PyBytes_Type; + if (likely(PyDict_Check(cpy_r_r167))) + cpy_r_r169 = cpy_r_r167; else { - arg_middleware = NULL; + CPy_TypeErrorTraceback("faster_ens/utils.py", "", 305, CPyStatic_faster_ens___utils___globals, "dict", cpy_r_r167); + goto CPyL95; } - if (arg_middleware != NULL) goto __LL67; - CPy_TypeError("object or None", obj_middleware); - goto fail; -__LL67: ; - PyObject *retval = CPyDef_faster_ens___utils___init_async_web3(arg_provider, arg_middleware); - return retval; -fail: ; - CPy_AddTraceback("faster_ens/utils.py", "init_async_web3", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - return NULL; -} - -char CPyDef_faster_ens___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; - 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; - void *cpy_r_r15; - void *cpy_r_r17; - PyObject *cpy_r_r18; - PyObject *cpy_r_r19; - PyObject *cpy_r_r20; - PyObject *cpy_r_r21; - char 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; - PyObject *cpy_r_r44; - PyObject *cpy_r_r45; - PyObject *cpy_r_r46; - PyObject *cpy_r_r47; - PyObject *cpy_r_r48; - PyObject *cpy_r_r49; - PyObject *cpy_r_r50; - PyObject *cpy_r_r51; - PyObject *cpy_r_r52; - int32_t cpy_r_r53; - char cpy_r_r54; - char cpy_r_r55; - cpy_r_r0 = CPyModule_builtins; - cpy_r_r1 = (PyObject *)&_Py_NoneStruct; - cpy_r_r2 = cpy_r_r0 != cpy_r_r1; - if (cpy_r_r2) goto CPyL3; - cpy_r_r3 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'builtins' */ - cpy_r_r4 = PyImport_Import(cpy_r_r3); - if (unlikely(cpy_r_r4 == NULL)) { - CPy_AddTraceback("faster_ens/utils.py", "", -1, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + cpy_r_r170 = PyDict_SetItem(cpy_r_r169, cpy_r_r168, cpy_r_r162); + CPy_DECREF(cpy_r_r169); + cpy_r_r171 = cpy_r_r170 >= 0; + if (unlikely(!cpy_r_r171)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL95; } - CPyModule_builtins = cpy_r_r4; - CPy_INCREF(CPyModule_builtins); - CPy_DECREF(cpy_r_r4); -CPyL3: ; - cpy_r_r5 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('datetime', 'timezone') */ - cpy_r_r6 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'datetime' */ - cpy_r_r7 = CPyStatic_faster_ens___utils___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_r_r172 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'dispatch_cache' */ + cpy_r_r173 = CPyObject_GetAttr(cpy_r_r165, cpy_r_r172); + CPy_DECREF(cpy_r_r165); + if (unlikely(cpy_r_r173 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL79; } - CPyModule_datetime = cpy_r_r8; - CPy_INCREF(CPyModule_datetime); - CPy_DECREF(cpy_r_r8); - cpy_r_r9 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('TYPE_CHECKING', 'Any', 'Collection', 'Optional', - 'Sequence', 'Tuple', 'Type', 'Union') */ - cpy_r_r10 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'typing' */ - cpy_r_r11 = CPyStatic_faster_ens___utils___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_r_r174 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'clear' */ + PyObject *cpy_r_r175[1] = {cpy_r_r173}; + cpy_r_r176 = (PyObject **)&cpy_r_r175; + cpy_r_r177 = PyObject_VectorcallMethod(cpy_r_r174, cpy_r_r176, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r177 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL96; + } else + goto CPyL97; +CPyL60: ; + CPy_DECREF(cpy_r_r173); + cpy_r_r178 = CPyDef_faster_ens___utils___is_empty_name_obj(); + if (unlikely(cpy_r_r178 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; } - CPyModule_typing = cpy_r_r12; - CPy_INCREF(CPyModule_typing); - CPy_DECREF(cpy_r_r12); - cpy_r_r13 = (PyObject **)&CPyModule_warnings; - PyObject **cpy_r_r14[1] = {cpy_r_r13}; - cpy_r_r15 = (void *)&cpy_r_r14; - int64_t cpy_r_r16[1] = {15}; - cpy_r_r17 = (void *)&cpy_r_r16; - cpy_r_r18 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* (('warnings', 'warnings', 'warnings'),) */ - cpy_r_r19 = CPyStatic_faster_ens___utils___globals; - cpy_r_r20 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_ens/utils.py' */ - cpy_r_r21 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '' */ - cpy_r_r22 = CPyImport_ImportMany(cpy_r_r18, cpy_r_r15, cpy_r_r19, cpy_r_r20, cpy_r_r21, cpy_r_r17); - if (!cpy_r_r22) goto CPyL17; - cpy_r_r23 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('Address', 'ChecksumAddress', 'HexAddress', 'HexStr') */ - cpy_r_r24 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'eth_typing' */ - cpy_r_r25 = CPyStatic_faster_ens___utils___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_INCREF_NO_IMM(cpy_r_r178); + cpy_r_is_empty_name = cpy_r_r178; + CPy_DECREF(cpy_r_is_empty_name); + cpy_r_r179 = CPyStatic_faster_ens___utils___globals; + cpy_r_r180 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_empty_name' */ + cpy_r_r181 = PyDict_SetItem(cpy_r_r179, cpy_r_r180, cpy_r_r178); + CPy_DECREF_NO_IMM(cpy_r_r178); + cpy_r_r182 = cpy_r_r181 >= 0; + if (unlikely(!cpy_r_r182)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL79; } - CPyModule_eth_typing = cpy_r_r26; - CPy_INCREF(CPyModule_eth_typing); - CPy_DECREF(cpy_r_r26); - cpy_r_r27 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('is_same_address', 'remove_0x_prefix', 'to_bytes', - 'to_normalized_address') */ - cpy_r_r28 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_eth_utils' */ - cpy_r_r29 = CPyStatic_faster_ens___utils___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_r_r183 = CPyStatic_faster_ens___utils___globals; + cpy_r_r184 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* '__mypyc_singledispatch_main_function_is_empty_name__' */ + cpy_r_r185 = CPyDict_GetItem(cpy_r_r183, cpy_r_r184); + if (unlikely(cpy_r_r185 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL79; } - CPyModule_faster_eth_utils = cpy_r_r30; - CPy_INCREF(CPyModule_faster_eth_utils); - CPy_DECREF(cpy_r_r30); - cpy_r_r31 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('HexBytes',) */ - cpy_r_r32 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_hexbytes' */ - cpy_r_r33 = CPyStatic_faster_ens___utils___globals; - cpy_r_r34 = CPyImport_ImportFromMany(cpy_r_r32, cpy_r_r31, cpy_r_r31, cpy_r_r33); - if (unlikely(cpy_r_r34 == NULL)) { + cpy_r_r186 = CPyModule_builtins; + cpy_r_r187 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'object' */ + cpy_r_r188 = CPyObject_GetAttr(cpy_r_r186, cpy_r_r187); + if (unlikely(cpy_r_r188 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL98; } - CPyModule_faster_hexbytes = cpy_r_r34; - CPy_INCREF(CPyModule_faster_hexbytes); - CPy_DECREF(cpy_r_r34); - cpy_r_r35 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('ENSTypeError', 'ENSValueError') */ - cpy_r_r36 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_ens.exceptions' */ - cpy_r_r37 = CPyStatic_faster_ens___utils___globals; - cpy_r_r38 = CPyImport_ImportFromMany(cpy_r_r36, cpy_r_r35, cpy_r_r35, cpy_r_r37); - if (unlikely(cpy_r_r38 == NULL)) { + cpy_r_r189 = CPyDict_Build(1, cpy_r_r188, cpy_r_r185); + CPy_DECREF(cpy_r_r188); + CPy_DECREF(cpy_r_r185); + if (unlikely(cpy_r_r189 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL79; } - CPyModule_faster_ens___exceptions = cpy_r_r38; - CPy_INCREF(CPyModule_faster_ens___exceptions); - CPy_DECREF(cpy_r_r38); - cpy_r_r39 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('ACCEPTABLE_STALE_HOURS', 'AUCTION_START_GAS_CONSTANT', - 'AUCTION_START_GAS_MARGINAL', 'EMPTY_ADDR_HEX', - 'EMPTY_SHA3_BYTES', 'REVERSE_REGISTRAR_DOMAIN') */ - cpy_r_r40 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_ens.constants' */ - cpy_r_r41 = CPyStatic_faster_ens___utils___globals; - cpy_r_r42 = CPyImport_ImportFromMany(cpy_r_r40, cpy_r_r39, cpy_r_r39, cpy_r_r41); - if (unlikely(cpy_r_r42 == NULL)) { + cpy_r_r190 = CPyStatic_faster_ens___utils___globals; + cpy_r_r191 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_empty_name' */ + cpy_r_r192 = CPyDict_GetItem(cpy_r_r190, cpy_r_r191); + if (unlikely(cpy_r_r192 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL99; } - CPyModule_faster_ens___constants = cpy_r_r42; - CPy_INCREF(CPyModule_faster_ens___constants); - CPy_DECREF(cpy_r_r42); - cpy_r_r43 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* ('ENSValidationError', 'InvalidName') */ - cpy_r_r44 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'faster_ens.exceptions' */ - cpy_r_r45 = CPyStatic_faster_ens___utils___globals; - cpy_r_r46 = CPyImport_ImportFromMany(cpy_r_r44, cpy_r_r43, cpy_r_r43, cpy_r_r45); - if (unlikely(cpy_r_r46 == NULL)) { + cpy_r_r193 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'registry' */ + cpy_r_r194 = PyObject_SetAttr(cpy_r_r192, cpy_r_r193, cpy_r_r189); + CPy_DECREF(cpy_r_r192); + CPy_DECREF(cpy_r_r189); + cpy_r_r195 = cpy_r_r194 >= 0; + if (unlikely(!cpy_r_r195)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL79; } - CPyModule_faster_ens___exceptions = cpy_r_r46; - CPy_INCREF(CPyModule_faster_ens___exceptions); - CPy_DECREF(cpy_r_r46); - cpy_r_r47 = CPyModule_builtins; - cpy_r_r48 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'object' */ - cpy_r_r49 = CPyObject_GetAttr(cpy_r_r47, cpy_r_r48); - if (unlikely(cpy_r_r49 == NULL)) { + cpy_r_r196 = CPyStatic_faster_ens___utils___globals; + cpy_r_r197 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_empty_name_none' */ + cpy_r_r198 = CPyDict_GetItem(cpy_r_r196, cpy_r_r197); + if (unlikely(cpy_r_r198 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL79; } - cpy_r_r50 = PyObject_Vectorcall(cpy_r_r49, 0, 0, 0); - CPy_DECREF(cpy_r_r49); - if (unlikely(cpy_r_r50 == NULL)) { + cpy_r_r199 = CPyStatic_faster_ens___utils___globals; + cpy_r_r200 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_empty_name' */ + cpy_r_r201 = CPyDict_GetItem(cpy_r_r199, cpy_r_r200); + if (unlikely(cpy_r_r201 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL100; } - cpy_r_r51 = CPyStatic_faster_ens___utils___globals; - cpy_r_r52 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'default' */ - cpy_r_r53 = CPyDict_SetItem(cpy_r_r51, cpy_r_r52, cpy_r_r50); - CPy_DECREF(cpy_r_r50); - cpy_r_r54 = cpy_r_r53 >= 0; - if (unlikely(!cpy_r_r54)) { + cpy_r_r202 = Py_None; + cpy_r_r203 = CPy_TYPE(cpy_r_r202); + cpy_r_r204 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'register' */ + PyObject *cpy_r_r205[2] = {cpy_r_r201, cpy_r_r203}; + cpy_r_r206 = (PyObject **)&cpy_r_r205; + cpy_r_r207 = PyObject_VectorcallMethod(cpy_r_r204, cpy_r_r206, 9223372036854775810ULL, 0); + if (unlikely(cpy_r_r207 == NULL)) { CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); - goto CPyL17; + goto CPyL101; + } + CPy_DECREF(cpy_r_r201); + CPy_DECREF(cpy_r_r203); + PyObject *cpy_r_r208[1] = {cpy_r_r198}; + cpy_r_r209 = (PyObject **)&cpy_r_r208; + cpy_r_r210 = PyObject_Vectorcall(cpy_r_r207, cpy_r_r209, 1, 0); + CPy_DECREF(cpy_r_r207); + if (unlikely(cpy_r_r210 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL100; + } + CPy_DECREF(cpy_r_r198); + cpy_r_r211 = CPyStatic_faster_ens___utils___globals; + cpy_r_r212 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_empty_name_none' */ + cpy_r_r213 = PyDict_SetItem(cpy_r_r211, cpy_r_r212, cpy_r_r210); + CPy_DECREF(cpy_r_r210); + cpy_r_r214 = cpy_r_r213 >= 0; + if (unlikely(!cpy_r_r214)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r215 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 0 */ + cpy_r_r216 = CPyStatic_faster_ens___utils___globals; + cpy_r_r217 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'is_empty_name' */ + cpy_r_r218 = CPyDict_GetItem(cpy_r_r216, cpy_r_r217); + if (unlikely(cpy_r_r218 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; + } + cpy_r_r219 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'registry' */ + cpy_r_r220 = CPyObject_GetAttr(cpy_r_r218, cpy_r_r219); + if (unlikely(cpy_r_r220 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL102; + } + cpy_r_r221 = (PyObject *)&PyUnicode_Type; + if (likely(PyDict_Check(cpy_r_r220))) + cpy_r_r222 = cpy_r_r220; + else { + CPy_TypeErrorTraceback("faster_ens/utils.py", "", 318, CPyStatic_faster_ens___utils___globals, "dict", cpy_r_r220); + goto CPyL102; + } + cpy_r_r223 = PyDict_SetItem(cpy_r_r222, cpy_r_r221, cpy_r_r215); + CPy_DECREF(cpy_r_r222); + cpy_r_r224 = cpy_r_r223 >= 0; + if (unlikely(!cpy_r_r224)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL102; + } + cpy_r_r225 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'dispatch_cache' */ + cpy_r_r226 = CPyObject_GetAttr(cpy_r_r218, cpy_r_r225); + CPy_DECREF(cpy_r_r218); + if (unlikely(cpy_r_r226 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL79; } + cpy_r_r227 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'clear' */ + PyObject *cpy_r_r228[1] = {cpy_r_r226}; + cpy_r_r229 = (PyObject **)&cpy_r_r228; + cpy_r_r230 = PyObject_VectorcallMethod(cpy_r_r227, cpy_r_r229, 9223372036854775809ULL, 0); + if (unlikely(cpy_r_r230 == NULL)) { + CPy_AddTraceback("faster_ens/utils.py", "", DIFFCHECK_PLACEHOLDER, CPyStatic_faster_ens___utils___globals); + goto CPyL103; + } else + goto CPyL104; +CPyL78: ; + CPy_DECREF(cpy_r_r226); return 1; -CPyL17: ; - cpy_r_r55 = 2; - return cpy_r_r55; +CPyL79: ; + cpy_r_r231 = 2; + return cpy_r_r231; +CPyL80: ; + CPy_DecRef(cpy_r_r66); + goto CPyL79; +CPyL81: ; + CPy_DecRef(cpy_r_r70); + goto CPyL79; +CPyL82: ; + CPy_DecRef(cpy_r_r80); + goto CPyL79; +CPyL83: ; + CPy_DecRef(cpy_r_r88); + goto CPyL79; +CPyL84: ; + CPy_DECREF(cpy_r_r92); + goto CPyL30; +CPyL85: ; + CPy_DecRef(cpy_r_r96); + goto CPyL79; +CPyL86: ; + CPy_DecRef(cpy_r_r104); + goto CPyL79; +CPyL87: ; + CPy_DECREF(cpy_r_r108); + goto CPyL36; +CPyL88: ; + CPy_DecRef(cpy_r_r116); + goto CPyL79; +CPyL89: ; + CPy_DecRef(cpy_r_r120); + goto CPyL79; +CPyL90: ; + CPy_DecRef(cpy_r_r129); + goto CPyL79; +CPyL91: ; + CPy_DecRef(cpy_r_r129); + CPy_DecRef(cpy_r_r132); + CPy_DecRef(cpy_r_r134); + goto CPyL79; +CPyL92: ; + CPy_DecRef(cpy_r_r149); + goto CPyL79; +CPyL93: ; + CPy_DecRef(cpy_r_r157); + goto CPyL79; +CPyL94: ; + CPy_DECREF(cpy_r_r161); + goto CPyL54; +CPyL95: ; + CPy_DecRef(cpy_r_r165); + goto CPyL79; +CPyL96: ; + CPy_DecRef(cpy_r_r173); + goto CPyL79; +CPyL97: ; + CPy_DECREF(cpy_r_r177); + goto CPyL60; +CPyL98: ; + CPy_DecRef(cpy_r_r185); + goto CPyL79; +CPyL99: ; + CPy_DecRef(cpy_r_r189); + goto CPyL79; +CPyL100: ; + CPy_DecRef(cpy_r_r198); + goto CPyL79; +CPyL101: ; + CPy_DecRef(cpy_r_r198); + CPy_DecRef(cpy_r_r201); + CPy_DecRef(cpy_r_r203); + goto CPyL79; +CPyL102: ; + CPy_DecRef(cpy_r_r218); + goto CPyL79; +CPyL103: ; + CPy_DecRef(cpy_r_r226); + goto CPyL79; +CPyL104: ; + CPy_DECREF(cpy_r_r230); + goto CPyL78; } static PyMethodDef faster_web3___beaconmodule_methods[] = { {NULL, NULL, 0, NULL} @@ -26132,10 +29126,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp68 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp68); - PyObject *__tmp69 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp69); + PyObject *__tmp75 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp75); + PyObject *__tmp76 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp76); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -26314,23 +29308,23 @@ PyObject *CPyPy_async_beacon___AsyncBeacon____async_make_get_request(PyObject *s PyObject *arg_params; if (obj_params == NULL) { arg_params = NULL; - goto __LL70; + goto __LL77; } if (PyDict_Check(obj_params)) arg_params = obj_params; else { arg_params = NULL; } - if (arg_params != NULL) goto __LL70; + if (arg_params != NULL) goto __LL77; if (obj_params == Py_None) arg_params = obj_params; else { arg_params = NULL; } - if (arg_params != NULL) goto __LL70; + if (arg_params != NULL) goto __LL77; CPy_TypeError("dict or None", obj_params); goto fail; -__LL70: ; +__LL77: ; PyObject *retval = CPyDef_async_beacon___AsyncBeacon____async_make_get_request(arg_self, arg_endpoint_uri, arg_params); return retval; fail: ; @@ -26927,10 +29921,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp71 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp71); - PyObject *__tmp72 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp72); + PyObject *__tmp78 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp78); + PyObject *__tmp79 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp79); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -27098,16 +30092,16 @@ PyObject *CPyPy_async_beacon___AsyncBeacon____async_make_post_request(PyObject * else { arg_body = NULL; } - if (arg_body != NULL) goto __LL73; + if (arg_body != NULL) goto __LL80; if (PyDict_Check(obj_body)) arg_body = obj_body; else { arg_body = NULL; } - if (arg_body != NULL) goto __LL73; + if (arg_body != NULL) goto __LL80; CPy_TypeError("union[list, dict]", obj_body); goto fail; -__LL73: ; +__LL80: ; PyObject *retval = CPyDef_async_beacon___AsyncBeacon____async_make_post_request(arg_self, arg_endpoint_uri, arg_body); return retval; fail: ; @@ -27617,10 +30611,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp74 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp74); - PyObject *__tmp75 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp75); + PyObject *__tmp81 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp81); + PyObject *__tmp82 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp82); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -28295,10 +31289,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp76 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp76); - PyObject *__tmp77 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp77); + PyObject *__tmp83 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp83); + PyObject *__tmp84 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp84); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -29009,10 +32003,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp78 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp78); - PyObject *__tmp79 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp79); + PyObject *__tmp85 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp85); + PyObject *__tmp86 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp86); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -29723,10 +32717,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp80 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp80); - PyObject *__tmp81 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp81); + PyObject *__tmp87 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp87); + PyObject *__tmp88 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp88); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -30437,10 +33431,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp82 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp82); - PyObject *__tmp83 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp83); + PyObject *__tmp89 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp89); + PyObject *__tmp90 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp90); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -31165,10 +34159,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp84 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp84); - PyObject *__tmp85 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp85); + PyObject *__tmp91 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp91); + PyObject *__tmp92 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp92); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -31898,10 +34892,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp86 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp86); - PyObject *__tmp87 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp87); + PyObject *__tmp93 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp93); + PyObject *__tmp94 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp94); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -32612,10 +35606,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp88 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp88); - PyObject *__tmp89 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp89); + PyObject *__tmp95 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp95); + PyObject *__tmp96 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp96); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -33326,10 +36320,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp90 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp90); - PyObject *__tmp91 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp91); + PyObject *__tmp97 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp97); + PyObject *__tmp98 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp98); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -34040,10 +37034,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp92 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp92); - PyObject *__tmp93 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp93); + PyObject *__tmp99 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp99); + PyObject *__tmp100 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp100); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -34719,10 +37713,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp94 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp94); - PyObject *__tmp95 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp95); + PyObject *__tmp101 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp101); + PyObject *__tmp102 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp102); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -35397,10 +38391,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp96 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp96); - PyObject *__tmp97 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp97); + PyObject *__tmp103 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp103); + PyObject *__tmp104 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp104); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -36094,10 +39088,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp98 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp98); - PyObject *__tmp99 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp99); + PyObject *__tmp105 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp105); + PyObject *__tmp106 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp106); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -36791,10 +39785,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp100 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp100); - PyObject *__tmp101 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp101); + PyObject *__tmp107 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp107); + PyObject *__tmp108 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp108); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -37488,10 +40482,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp102 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp102); - PyObject *__tmp103 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp103); + PyObject *__tmp109 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp109); + PyObject *__tmp110 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp110); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -38185,10 +41179,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp104 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp104); - PyObject *__tmp105 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp105); + PyObject *__tmp111 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp111); + PyObject *__tmp112 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp112); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -38882,10 +41876,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp106 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp106); - PyObject *__tmp107 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp107); + PyObject *__tmp113 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp113); + PyObject *__tmp114 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp114); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -39579,10 +42573,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp108 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp108); - PyObject *__tmp109 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp109); + PyObject *__tmp115 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp115); + PyObject *__tmp116 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp116); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -40241,10 +43235,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp110 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp110); - PyObject *__tmp111 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp111); + PyObject *__tmp117 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp117); + PyObject *__tmp118 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp118); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -40884,10 +43878,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp112 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp112); - PyObject *__tmp113 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp113); + PyObject *__tmp119 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp119); + PyObject *__tmp120 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp120); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -41527,10 +44521,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp114 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp114); - PyObject *__tmp115 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp115); + PyObject *__tmp121 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp121); + PyObject *__tmp122 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp122); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -42170,10 +45164,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp116 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp116); - PyObject *__tmp117 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp117); + PyObject *__tmp123 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp123); + PyObject *__tmp124 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp124); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -42813,10 +45807,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp118 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp118); - PyObject *__tmp119 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp119); + PyObject *__tmp125 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp125); + PyObject *__tmp126 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp126); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -43456,10 +46450,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp120 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp120); - PyObject *__tmp121 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp121); + PyObject *__tmp127 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp127); + PyObject *__tmp128 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp128); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -44099,10 +47093,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp122 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp122); - PyObject *__tmp123 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp123); + PyObject *__tmp129 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp129); + PyObject *__tmp130 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp130); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -44742,10 +47736,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp124 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp124); - PyObject *__tmp125 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp125); + PyObject *__tmp131 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp131); + PyObject *__tmp132 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp132); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -45385,10 +48379,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp126 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp126); - PyObject *__tmp127 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp127); + PyObject *__tmp133 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp133); + PyObject *__tmp134 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp134); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -46028,10 +49022,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp128 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp128); - PyObject *__tmp129 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp129); + PyObject *__tmp135 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp135); + PyObject *__tmp136 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp136); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -46671,10 +49665,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp130 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp130); - PyObject *__tmp131 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp131); + PyObject *__tmp137 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp137); + PyObject *__tmp138 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp138); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -47349,10 +50343,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp132 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp132); - PyObject *__tmp133 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp133); + PyObject *__tmp139 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp139); + PyObject *__tmp140 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp140); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -48028,10 +51022,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp134 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp134); - PyObject *__tmp135 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp135); + PyObject *__tmp141 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp141); + PyObject *__tmp142 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp142); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -48671,10 +51665,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp136 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp136); - PyObject *__tmp137 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp137); + PyObject *__tmp143 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp143); + PyObject *__tmp144 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp144); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -49314,10 +52308,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp138 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp138); - PyObject *__tmp139 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp139); + PyObject *__tmp145 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp145); + PyObject *__tmp146 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp146); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -49992,10 +52986,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp140 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp140); - PyObject *__tmp141 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp141); + PyObject *__tmp147 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp147); + PyObject *__tmp148 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp148); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -50654,10 +53648,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp142 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp142); - PyObject *__tmp143 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp143); + PyObject *__tmp149 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp149); + PyObject *__tmp150 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp150); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -51358,10 +54352,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp144 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp144); - PyObject *__tmp145 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp145); + PyObject *__tmp151 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp151); + PyObject *__tmp152 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp152); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -52001,10 +54995,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp146 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp146); - PyObject *__tmp147 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp147); + PyObject *__tmp153 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp153); + PyObject *__tmp154 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp154); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -52644,10 +55638,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp148 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp148); - PyObject *__tmp149 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp149); + PyObject *__tmp155 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp155); + PyObject *__tmp156 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp156); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -53443,10 +56437,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp150 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp150); - PyObject *__tmp151 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp151); + PyObject *__tmp157 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp157); + PyObject *__tmp158 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp158); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -53625,23 +56619,23 @@ PyObject *CPyPy_async_beacon___AsyncBeacon___get_blob_sidecars(PyObject *self, P PyObject *arg_indices; if (obj_indices == NULL) { arg_indices = NULL; - goto __LL152; + goto __LL159; } if (PyList_Check(obj_indices)) arg_indices = obj_indices; else { arg_indices = NULL; } - if (arg_indices != NULL) goto __LL152; + if (arg_indices != NULL) goto __LL159; if (obj_indices == Py_None) arg_indices = obj_indices; else { arg_indices = NULL; } - if (arg_indices != NULL) goto __LL152; + if (arg_indices != NULL) goto __LL159; CPy_TypeError("list or None", obj_indices); goto fail; -__LL152: ; +__LL159: ; PyObject *retval = CPyDef_async_beacon___AsyncBeacon___get_blob_sidecars(arg_self, arg_block_id, arg_indices); return retval; fail: ; @@ -54197,10 +57191,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp153 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp153); - PyObject *__tmp154 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp154); + PyObject *__tmp160 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp160); + PyObject *__tmp161 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp161); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -54913,10 +57907,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp155 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp155); - PyObject *__tmp156 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp156); + PyObject *__tmp162 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp162); + PyObject *__tmp163 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp163); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -55621,10 +58615,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp157 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp157); - PyObject *__tmp158 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp158); + PyObject *__tmp164 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp164); + PyObject *__tmp165 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp165); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -56348,10 +59342,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp159 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp159); - PyObject *__tmp160 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp160); + PyObject *__tmp166 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp166); + PyObject *__tmp167 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp167); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -57369,23 +60363,23 @@ PyObject *CPyPy_beacon___beacon___Beacon____make_get_request(PyObject *self, PyO PyObject *arg_params; if (obj_params == NULL) { arg_params = NULL; - goto __LL161; + goto __LL168; } if (PyDict_Check(obj_params)) arg_params = obj_params; else { arg_params = NULL; } - if (arg_params != NULL) goto __LL161; + if (arg_params != NULL) goto __LL168; if (obj_params == Py_None) arg_params = obj_params; else { arg_params = NULL; } - if (arg_params != NULL) goto __LL161; + if (arg_params != NULL) goto __LL168; CPy_TypeError("dict or None", obj_params); goto fail; -__LL161: ; +__LL168: ; PyObject *retval = CPyDef_beacon___beacon___Beacon____make_get_request(arg_self, arg_endpoint_url, arg_params); return retval; fail: ; @@ -57475,16 +60469,16 @@ PyObject *CPyPy_beacon___beacon___Beacon____make_post_request(PyObject *self, Py else { arg_body = NULL; } - if (arg_body != NULL) goto __LL162; + if (arg_body != NULL) goto __LL169; if (PyDict_Check(obj_body)) arg_body = obj_body; else { arg_body = NULL; } - if (arg_body != NULL) goto __LL162; + if (arg_body != NULL) goto __LL169; CPy_TypeError("union[list, dict]", obj_body); goto fail; -__LL162: ; +__LL169: ; PyObject *retval = CPyDef_beacon___beacon___Beacon____make_post_request(arg_self, arg_endpoint_url, arg_body); return retval; fail: ; @@ -59827,23 +62821,23 @@ PyObject *CPyPy_beacon___beacon___Beacon___get_blob_sidecars(PyObject *self, PyO PyObject *arg_indices; if (obj_indices == NULL) { arg_indices = NULL; - goto __LL163; + goto __LL170; } if (PyList_Check(obj_indices)) arg_indices = obj_indices; else { arg_indices = NULL; } - if (arg_indices != NULL) goto __LL163; + if (arg_indices != NULL) goto __LL170; if (obj_indices == Py_None) arg_indices = obj_indices; else { arg_indices = NULL; } - if (arg_indices != NULL) goto __LL163; + if (arg_indices != NULL) goto __LL170; CPy_TypeError("list or None", obj_indices); goto fail; -__LL163: ; +__LL170: ; PyObject *retval = CPyDef_beacon___beacon___Beacon___get_blob_sidecars(arg_self, arg_block_id, arg_indices); return retval; fail: ; @@ -60648,12 +63642,12 @@ caching_utils___RequestInformation_get_response_formatters(faster_web3____utils_ PyObject *retval = PyTuple_New(3); if (unlikely(retval == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp164 = self->_response_formatters.f0; - PyTuple_SET_ITEM(retval, 0, __tmp164); - PyObject *__tmp165 = self->_response_formatters.f1; - PyTuple_SET_ITEM(retval, 1, __tmp165); - PyObject *__tmp166 = self->_response_formatters.f2; - PyTuple_SET_ITEM(retval, 2, __tmp166); + PyObject *__tmp171 = self->_response_formatters.f0; + PyTuple_SET_ITEM(retval, 0, __tmp171); + PyObject *__tmp172 = self->_response_formatters.f1; + PyTuple_SET_ITEM(retval, 1, __tmp172); + PyObject *__tmp173 = self->_response_formatters.f2; + PyTuple_SET_ITEM(retval, 2, __tmp173); return retval; } @@ -60671,56 +63665,56 @@ caching_utils___RequestInformation_set_response_formatters(faster_web3____utils_ CPy_DECREF(self->_response_formatters.f2); } tuple_T3OOO tmp; - PyObject *__tmp167; + PyObject *__tmp174; if (unlikely(!(PyTuple_Check(value) && PyTuple_GET_SIZE(value) == 3))) { - __tmp167 = NULL; - goto __LL168; + __tmp174 = NULL; + goto __LL175; } if (PyDict_Check(PyTuple_GET_ITEM(value, 0))) - __tmp167 = PyTuple_GET_ITEM(value, 0); - else { - __tmp167 = NULL; - } - if (__tmp167 != NULL) goto __LL169; - __tmp167 = PyTuple_GET_ITEM(value, 0); - if (__tmp167 != NULL) goto __LL169; - __tmp167 = NULL; -__LL169: ; - if (__tmp167 == NULL) goto __LL168; - __tmp167 = PyTuple_GET_ITEM(value, 1); - if (__tmp167 == NULL) goto __LL168; - __tmp167 = PyTuple_GET_ITEM(value, 2); - if (__tmp167 == NULL) goto __LL168; - __tmp167 = value; -__LL168: ; - if (unlikely(__tmp167 == NULL)) { + __tmp174 = PyTuple_GET_ITEM(value, 0); + else { + __tmp174 = NULL; + } + if (__tmp174 != NULL) goto __LL176; + __tmp174 = PyTuple_GET_ITEM(value, 0); + if (__tmp174 != NULL) goto __LL176; + __tmp174 = NULL; +__LL176: ; + if (__tmp174 == NULL) goto __LL175; + __tmp174 = PyTuple_GET_ITEM(value, 1); + if (__tmp174 == NULL) goto __LL175; + __tmp174 = PyTuple_GET_ITEM(value, 2); + if (__tmp174 == NULL) goto __LL175; + __tmp174 = value; +__LL175: ; + if (unlikely(__tmp174 == NULL)) { CPy_TypeError("tuple[union[dict, object], object, object]", value); return -1; } else { - PyObject *__tmp170 = PyTuple_GET_ITEM(value, 0); - CPy_INCREF(__tmp170); - PyObject *__tmp171; - if (PyDict_Check(__tmp170)) - __tmp171 = __tmp170; + PyObject *__tmp177 = PyTuple_GET_ITEM(value, 0); + CPy_INCREF(__tmp177); + PyObject *__tmp178; + if (PyDict_Check(__tmp177)) + __tmp178 = __tmp177; else { - __tmp171 = NULL; + __tmp178 = NULL; } - if (__tmp171 != NULL) goto __LL172; - __tmp171 = __tmp170; - if (__tmp171 != NULL) goto __LL172; - CPy_TypeError("union[dict, object]", __tmp170); - __tmp171 = NULL; -__LL172: ; - tmp.f0 = __tmp171; - PyObject *__tmp173 = PyTuple_GET_ITEM(value, 1); - CPy_INCREF(__tmp173); - PyObject *__tmp174; - __tmp174 = __tmp173; - tmp.f1 = __tmp174; - PyObject *__tmp175 = PyTuple_GET_ITEM(value, 2); - CPy_INCREF(__tmp175); - PyObject *__tmp176; - __tmp176 = __tmp175; - tmp.f2 = __tmp176; + if (__tmp178 != NULL) goto __LL179; + __tmp178 = __tmp177; + if (__tmp178 != NULL) goto __LL179; + CPy_TypeError("union[dict, object]", __tmp177); + __tmp178 = NULL; +__LL179: ; + tmp.f0 = __tmp178; + PyObject *__tmp180 = PyTuple_GET_ITEM(value, 1); + CPy_INCREF(__tmp180); + PyObject *__tmp181; + __tmp181 = __tmp180; + tmp.f1 = __tmp181; + PyObject *__tmp182 = PyTuple_GET_ITEM(value, 2); + CPy_INCREF(__tmp182); + PyObject *__tmp183; + __tmp183 = __tmp182; + tmp.f2 = __tmp183; } CPy_INCREF(tmp.f0); CPy_INCREF(tmp.f1); @@ -60759,16 +63753,16 @@ caching_utils___RequestInformation_set_subscription_id(faster_web3____utils___ca else { tmp = NULL; } - if (tmp != NULL) goto __LL177; + if (tmp != NULL) goto __LL184; if (value == Py_None) tmp = value; else { tmp = NULL; } - if (tmp != NULL) goto __LL177; + if (tmp != NULL) goto __LL184; CPy_TypeError("str or None", value); tmp = NULL; -__LL177: ; +__LL184: ; if (!tmp) return -1; CPy_INCREF(tmp); @@ -63931,10 +66925,10 @@ CPyL66: ; cpy_r_r83 = PyTuple_New(2); if (unlikely(cpy_r_r83 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp178 = cpy_r_r82.f0; - PyTuple_SET_ITEM(cpy_r_r83, 0, __tmp178); - PyObject *__tmp179 = cpy_r_r82.f1; - PyTuple_SET_ITEM(cpy_r_r83, 1, __tmp179); + PyObject *__tmp185 = cpy_r_r82.f0; + PyTuple_SET_ITEM(cpy_r_r83, 0, __tmp185); + PyObject *__tmp186 = cpy_r_r82.f1; + PyTuple_SET_ITEM(cpy_r_r83, 1, __tmp186); CPyList_SetItemUnsafe(cpy_r_r71, cpy_r_r72, cpy_r_r83); cpy_r_r84 = cpy_r_r72 + 1; cpy_r_r72 = cpy_r_r84; @@ -64198,74 +67192,74 @@ PyObject *CPyPy_caching_utils___RequestInformation_____init__(PyObject *self, Py } PyObject *arg_params = obj_params; tuple_T3OOO arg_response_formatters; - PyObject *__tmp180; + PyObject *__tmp187; if (unlikely(!(PyTuple_Check(obj_response_formatters) && PyTuple_GET_SIZE(obj_response_formatters) == 3))) { - __tmp180 = NULL; - goto __LL181; + __tmp187 = NULL; + goto __LL188; } if (PyDict_Check(PyTuple_GET_ITEM(obj_response_formatters, 0))) - __tmp180 = PyTuple_GET_ITEM(obj_response_formatters, 0); - else { - __tmp180 = NULL; - } - if (__tmp180 != NULL) goto __LL182; - __tmp180 = PyTuple_GET_ITEM(obj_response_formatters, 0); - if (__tmp180 != NULL) goto __LL182; - __tmp180 = NULL; -__LL182: ; - if (__tmp180 == NULL) goto __LL181; - __tmp180 = PyTuple_GET_ITEM(obj_response_formatters, 1); - if (__tmp180 == NULL) goto __LL181; - __tmp180 = PyTuple_GET_ITEM(obj_response_formatters, 2); - if (__tmp180 == NULL) goto __LL181; - __tmp180 = obj_response_formatters; -__LL181: ; - if (unlikely(__tmp180 == NULL)) { + __tmp187 = PyTuple_GET_ITEM(obj_response_formatters, 0); + else { + __tmp187 = NULL; + } + if (__tmp187 != NULL) goto __LL189; + __tmp187 = PyTuple_GET_ITEM(obj_response_formatters, 0); + if (__tmp187 != NULL) goto __LL189; + __tmp187 = NULL; +__LL189: ; + if (__tmp187 == NULL) goto __LL188; + __tmp187 = PyTuple_GET_ITEM(obj_response_formatters, 1); + if (__tmp187 == NULL) goto __LL188; + __tmp187 = PyTuple_GET_ITEM(obj_response_formatters, 2); + if (__tmp187 == NULL) goto __LL188; + __tmp187 = obj_response_formatters; +__LL188: ; + if (unlikely(__tmp187 == NULL)) { CPy_TypeError("tuple[union[dict, object], object, object]", obj_response_formatters); goto fail; } else { - PyObject *__tmp183 = PyTuple_GET_ITEM(obj_response_formatters, 0); - PyObject *__tmp184; - if (PyDict_Check(__tmp183)) - __tmp184 = __tmp183; + PyObject *__tmp190 = PyTuple_GET_ITEM(obj_response_formatters, 0); + PyObject *__tmp191; + if (PyDict_Check(__tmp190)) + __tmp191 = __tmp190; else { - __tmp184 = NULL; + __tmp191 = NULL; } - if (__tmp184 != NULL) goto __LL185; - __tmp184 = __tmp183; - if (__tmp184 != NULL) goto __LL185; - CPy_TypeError("union[dict, object]", __tmp183); - __tmp184 = NULL; -__LL185: ; - arg_response_formatters.f0 = __tmp184; - PyObject *__tmp186 = PyTuple_GET_ITEM(obj_response_formatters, 1); - PyObject *__tmp187; - __tmp187 = __tmp186; - arg_response_formatters.f1 = __tmp187; - PyObject *__tmp188 = PyTuple_GET_ITEM(obj_response_formatters, 2); - PyObject *__tmp189; - __tmp189 = __tmp188; - arg_response_formatters.f2 = __tmp189; + if (__tmp191 != NULL) goto __LL192; + __tmp191 = __tmp190; + if (__tmp191 != NULL) goto __LL192; + CPy_TypeError("union[dict, object]", __tmp190); + __tmp191 = NULL; +__LL192: ; + arg_response_formatters.f0 = __tmp191; + PyObject *__tmp193 = PyTuple_GET_ITEM(obj_response_formatters, 1); + PyObject *__tmp194; + __tmp194 = __tmp193; + arg_response_formatters.f1 = __tmp194; + PyObject *__tmp195 = PyTuple_GET_ITEM(obj_response_formatters, 2); + PyObject *__tmp196; + __tmp196 = __tmp195; + arg_response_formatters.f2 = __tmp196; } PyObject *arg_subscription_id; if (obj_subscription_id == NULL) { arg_subscription_id = NULL; - goto __LL190; + goto __LL197; } if (PyUnicode_Check(obj_subscription_id)) arg_subscription_id = obj_subscription_id; else { arg_subscription_id = NULL; } - if (arg_subscription_id != NULL) goto __LL190; + if (arg_subscription_id != NULL) goto __LL197; if (obj_subscription_id == Py_None) arg_subscription_id = obj_subscription_id; else { arg_subscription_id = NULL; } - if (arg_subscription_id != NULL) goto __LL190; + if (arg_subscription_id != NULL) goto __LL197; CPy_TypeError("str or None", obj_subscription_id); goto fail; -__LL190: ; +__LL197: ; char retval = CPyDef_caching_utils___RequestInformation_____init__(arg_self, arg_method, arg_params, arg_response_formatters, arg_subscription_id); if (retval == 2) { return NULL; @@ -64328,16 +67322,16 @@ char CPyDef_caching_utils___is_cacheable_request(PyObject *cpy_r_provider, PyObj else { cpy_r_r5 = NULL; } - if (cpy_r_r5 != NULL) goto __LL191; + if (cpy_r_r5 != NULL) goto __LL198; if (PyTuple_Check(cpy_r_r4)) cpy_r_r5 = cpy_r_r4; else { cpy_r_r5 = NULL; } - if (cpy_r_r5 != NULL) goto __LL191; + if (cpy_r_r5 != NULL) goto __LL198; CPy_TypeErrorTraceback("faster_web3/_utils/caching/caching_utils.py", "is_cacheable_request", 157, CPyStatic_caching_utils___globals, "union[set, tuple]", cpy_r_r4); goto CPyL21; -__LL191: ; +__LL198: ; cpy_r_r6 = PySequence_Contains(cpy_r_r5, cpy_r_method); CPy_DECREF(cpy_r_r5); cpy_r_r7 = cpy_r_r6 >= 0; @@ -64634,16 +67628,16 @@ CPyL19: ; else { cpy_r_r41 = NULL; } - if (cpy_r_r41 != NULL) goto __LL192; + if (cpy_r_r41 != NULL) goto __LL199; if (PyLong_Check(cpy_r_r40)) cpy_r_r41 = cpy_r_r40; else { cpy_r_r41 = NULL; } - if (cpy_r_r41 != NULL) goto __LL192; + if (cpy_r_r41 != NULL) goto __LL199; CPy_TypeErrorTraceback("faster_web3/_utils/caching/caching_utils.py", "set_threshold_if_empty", 227, CPyStatic_caching_utils___globals, "union[faster_web3.utils.caching.RequestCacheValidationThreshold, int]", cpy_r_r40); goto CPyL22; -__LL192: ; +__LL199: ; cpy_r_r42 = CPyStatics[DIFFCHECK_PLACEHOLDER]; /* 'request_cache_validation_threshold' */ cpy_r_r43 = PyObject_SetAttr(cpy_r_provider, cpy_r_r42, cpy_r_r41); CPy_DECREF(cpy_r_r41); @@ -64696,8 +67690,8 @@ CPyL28: ; if (!cpy_r_r54) goto CPyL31; CPy_Unreachable(); CPyL30: ; - tuple_T3OOO __tmp193 = { NULL, NULL, NULL }; - cpy_r_r55 = __tmp193; + tuple_T3OOO __tmp200 = { NULL, NULL, NULL }; + cpy_r_r55 = __tmp200; cpy_r_r56 = cpy_r_r55; goto CPyL32; CPyL31: ; @@ -65183,10 +68177,10 @@ CPyL8: ; cpy_r_r12 = PyTuple_New(2); if (unlikely(cpy_r_r12 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp194 = cpy_r_r11.f0; - PyTuple_SET_ITEM(cpy_r_r12, 0, __tmp194); - PyObject *__tmp195 = cpy_r_r11.f1; - PyTuple_SET_ITEM(cpy_r_r12, 1, __tmp195); + PyObject *__tmp201 = cpy_r_r11.f0; + PyTuple_SET_ITEM(cpy_r_r12, 0, __tmp201); + PyObject *__tmp202 = cpy_r_r11.f1; + PyTuple_SET_ITEM(cpy_r_r12, 1, __tmp202); cpy_r_r13 = PyObject_Str(cpy_r_r12); CPy_DECREF(cpy_r_r12); if (unlikely(cpy_r_r13 == NULL)) { @@ -65353,8 +68347,8 @@ CPyL35: ; CPyL36: ; CPy_Unreachable(); CPyL37: ; - tuple_T3OOO __tmp196 = { NULL, NULL, NULL }; - cpy_r_r50 = __tmp196; + tuple_T3OOO __tmp203 = { NULL, NULL, NULL }; + cpy_r_r50 = __tmp203; cpy_r_r51 = cpy_r_r50; goto CPyL39; CPyL38: ; @@ -66168,16 +69162,16 @@ CPyL63: ; else { cpy_r_r83 = NULL; } - if (cpy_r_r83 != NULL) goto __LL197; + if (cpy_r_r83 != NULL) goto __LL204; if (PyLong_Check(cpy_r_r82)) cpy_r_r83 = cpy_r_r82; else { cpy_r_r83 = NULL; } - if (cpy_r_r83 != NULL) goto __LL197; + if (cpy_r_r83 != NULL) goto __LL204; CPy_TypeErrorTraceback("faster_web3/_utils/caching/caching_utils.py", "async_set_threshold_if_empty", 324, CPyStatic_caching_utils___globals, "union[faster_web3.utils.caching.RequestCacheValidationThreshold, int]", cpy_r_r82); goto CPyL67; -__LL197: ; +__LL204: ; cpy_r_r84 = ((faster_web3____utils___caching___caching_utils___async_set_threshold_if_empty_genObject *)cpy_r___mypyc_self__)->___mypyc_generator_attribute__provider; if (unlikely(cpy_r_r84 == NULL)) { CPy_AttributeError("faster_web3/_utils/caching/caching_utils.py", "async_set_threshold_if_empty", "async_set_threshold_if_empty_gen", "provider", 323, CPyStatic_caching_utils___globals); @@ -66271,8 +69265,8 @@ CPyL77: ; if (!cpy_r_r101) goto CPyL80; CPy_Unreachable(); CPyL79: ; - tuple_T3OOO __tmp198 = { NULL, NULL, NULL }; - cpy_r_r102 = __tmp198; + tuple_T3OOO __tmp205 = { NULL, NULL, NULL }; + cpy_r_r102 = __tmp205; cpy_r_r103 = cpy_r_r102; goto CPyL81; CPyL80: ; @@ -66599,10 +69593,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp199 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp199); - PyObject *__tmp200 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp200); + PyObject *__tmp206 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp206); + PyObject *__tmp207 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp207); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -67842,10 +70836,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp201 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp201); - PyObject *__tmp202 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp202); + PyObject *__tmp208 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp208); + PyObject *__tmp209 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp209); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -68355,8 +71349,8 @@ PyObject *CPyDef_caching_utils___wrapper_gen___3_363_____mypyc_generator_helper_ cpy_r_r9 = cpy_r_r8; cpy_r_r10 = NULL; cpy_r_r11 = cpy_r_r10; - tuple_T3OOO __tmp203 = { NULL, NULL, NULL }; - cpy_r_r12 = __tmp203; + tuple_T3OOO __tmp210 = { NULL, NULL, NULL }; + cpy_r_r12 = __tmp210; cpy_r_r13 = cpy_r_r12; cpy_r_r14 = NULL; cpy_r_r15 = cpy_r_r14; @@ -68504,10 +71498,10 @@ CPyL22: ; cpy_r_r39 = PyTuple_New(2); if (unlikely(cpy_r_r39 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp204 = cpy_r_r38.f0; - PyTuple_SET_ITEM(cpy_r_r39, 0, __tmp204); - PyObject *__tmp205 = cpy_r_r38.f1; - PyTuple_SET_ITEM(cpy_r_r39, 1, __tmp205); + PyObject *__tmp211 = cpy_r_r38.f0; + PyTuple_SET_ITEM(cpy_r_r39, 0, __tmp211); + PyObject *__tmp212 = cpy_r_r38.f1; + PyTuple_SET_ITEM(cpy_r_r39, 1, __tmp212); cpy_r_r40 = PyObject_Str(cpy_r_r39); CPy_DECREF(cpy_r_r39); if (unlikely(cpy_r_r40 == NULL)) { @@ -69566,8 +72560,8 @@ CPyL187: ; CPyL188: ; CPy_Unreachable(); CPyL189: ; - tuple_T3OOO __tmp206 = { NULL, NULL, NULL }; - cpy_r_r202 = __tmp206; + tuple_T3OOO __tmp213 = { NULL, NULL, NULL }; + cpy_r_r202 = __tmp213; cpy_r_r13 = cpy_r_r202; goto CPyL191; CPyL190: ; @@ -70721,10 +73715,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp207 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp207); - PyObject *__tmp208 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp208); + PyObject *__tmp214 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp214); + PyObject *__tmp215 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp215); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -71287,10 +74281,10 @@ CPyL22: ; cpy_r_r25 = PyTuple_New(2); if (unlikely(cpy_r_r25 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp209 = cpy_r_r24.f0; - PyTuple_SET_ITEM(cpy_r_r25, 0, __tmp209); - PyObject *__tmp210 = cpy_r_r24.f1; - PyTuple_SET_ITEM(cpy_r_r25, 1, __tmp210); + PyObject *__tmp216 = cpy_r_r24.f0; + PyTuple_SET_ITEM(cpy_r_r25, 0, __tmp216); + PyObject *__tmp217 = cpy_r_r24.f1; + PyTuple_SET_ITEM(cpy_r_r25, 1, __tmp217); cpy_r_r26 = PyObject_Str(cpy_r_r25); CPy_DECREF(cpy_r_r25); if (unlikely(cpy_r_r26 == NULL)) { @@ -71943,10 +74937,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp211 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp211); - PyObject *__tmp212 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp212); + PyObject *__tmp218 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp218); + PyObject *__tmp219 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp219); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -72577,8 +75571,8 @@ PyObject *CPyDef_caching_utils___wrapper_gen___3_422_____mypyc_generator_helper_ cpy_r_r9 = cpy_r_r8; cpy_r_r10 = NULL; cpy_r_r11 = cpy_r_r10; - tuple_T3OOO __tmp213 = { NULL, NULL, NULL }; - cpy_r_r12 = __tmp213; + tuple_T3OOO __tmp220 = { NULL, NULL, NULL }; + cpy_r_r12 = __tmp220; cpy_r_r13 = cpy_r_r12; cpy_r_r14 = NULL; cpy_r_r15 = cpy_r_r14; @@ -72778,10 +75772,10 @@ CPyL29: ; cpy_r_r48 = PyTuple_New(2); if (unlikely(cpy_r_r48 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp214 = cpy_r_r47.f0; - PyTuple_SET_ITEM(cpy_r_r48, 0, __tmp214); - PyObject *__tmp215 = cpy_r_r47.f1; - PyTuple_SET_ITEM(cpy_r_r48, 1, __tmp215); + PyObject *__tmp221 = cpy_r_r47.f0; + PyTuple_SET_ITEM(cpy_r_r48, 0, __tmp221); + PyObject *__tmp222 = cpy_r_r47.f1; + PyTuple_SET_ITEM(cpy_r_r48, 1, __tmp222); cpy_r_r49 = PyObject_Str(cpy_r_r48); CPy_DECREF(cpy_r_r48); if (unlikely(cpy_r_r49 == NULL)) { @@ -73832,8 +76826,8 @@ CPyL193: ; CPyL194: ; CPy_Unreachable(); CPyL195: ; - tuple_T3OOO __tmp216 = { NULL, NULL, NULL }; - cpy_r_r210 = __tmp216; + tuple_T3OOO __tmp223 = { NULL, NULL, NULL }; + cpy_r_r210 = __tmp223; cpy_r_r13 = cpy_r_r210; goto CPyL197; CPyL196: ; @@ -74965,10 +77959,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp217 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp217); - PyObject *__tmp218 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp218); + PyObject *__tmp224 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp224); + PyObject *__tmp225 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp225); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -77574,10 +80568,10 @@ CPyL221: ; cpy_r_r529 = PyTuple_New(2); if (unlikely(cpy_r_r529 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp219 = cpy_r_r528.f0; - PyTuple_SET_ITEM(cpy_r_r529, 0, __tmp219); - PyObject *__tmp220 = cpy_r_r528.f1; - PyTuple_SET_ITEM(cpy_r_r529, 1, __tmp220); + PyObject *__tmp226 = cpy_r_r528.f0; + PyTuple_SET_ITEM(cpy_r_r529, 0, __tmp226); + PyObject *__tmp227 = cpy_r_r528.f1; + PyTuple_SET_ITEM(cpy_r_r529, 1, __tmp227); cpy_r_r530 = PyObject_GetItem(cpy_r_r523, cpy_r_r529); CPy_DECREF(cpy_r_r523); CPy_DECREF(cpy_r_r529); @@ -77635,12 +80629,12 @@ CPyL221: ; cpy_r_r551 = PyTuple_New(3); if (unlikely(cpy_r_r551 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp221 = cpy_r_r550.f0; - PyTuple_SET_ITEM(cpy_r_r551, 0, __tmp221); - PyObject *__tmp222 = cpy_r_r550.f1; - PyTuple_SET_ITEM(cpy_r_r551, 1, __tmp222); - PyObject *__tmp223 = cpy_r_r550.f2; - PyTuple_SET_ITEM(cpy_r_r551, 2, __tmp223); + PyObject *__tmp228 = cpy_r_r550.f0; + PyTuple_SET_ITEM(cpy_r_r551, 0, __tmp228); + PyObject *__tmp229 = cpy_r_r550.f1; + PyTuple_SET_ITEM(cpy_r_r551, 1, __tmp229); + PyObject *__tmp230 = cpy_r_r550.f2; + PyTuple_SET_ITEM(cpy_r_r551, 2, __tmp230); cpy_r_r552 = PyObject_GetItem(cpy_r_r542, cpy_r_r551); CPy_DECREF(cpy_r_r542); CPy_DECREF(cpy_r_r551); @@ -77654,10 +80648,10 @@ CPyL221: ; cpy_r_r554 = PyTuple_New(2); if (unlikely(cpy_r_r554 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp224 = cpy_r_r553.f0; - PyTuple_SET_ITEM(cpy_r_r554, 0, __tmp224); - PyObject *__tmp225 = cpy_r_r553.f1; - PyTuple_SET_ITEM(cpy_r_r554, 1, __tmp225); + PyObject *__tmp231 = cpy_r_r553.f0; + PyTuple_SET_ITEM(cpy_r_r554, 0, __tmp231); + PyObject *__tmp232 = cpy_r_r553.f1; + PyTuple_SET_ITEM(cpy_r_r554, 1, __tmp232); cpy_r_r555 = PyObject_GetItem(cpy_r_r538, cpy_r_r554); CPy_DECREF(cpy_r_r538); CPy_DECREF(cpy_r_r554); @@ -77670,10 +80664,10 @@ CPyL221: ; cpy_r_r557 = PyTuple_New(2); if (unlikely(cpy_r_r557 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp226 = cpy_r_r556.f0; - PyTuple_SET_ITEM(cpy_r_r557, 0, __tmp226); - PyObject *__tmp227 = cpy_r_r556.f1; - PyTuple_SET_ITEM(cpy_r_r557, 1, __tmp227); + PyObject *__tmp233 = cpy_r_r556.f0; + PyTuple_SET_ITEM(cpy_r_r557, 0, __tmp233); + PyObject *__tmp234 = cpy_r_r556.f1; + PyTuple_SET_ITEM(cpy_r_r557, 1, __tmp234); cpy_r_r558 = PyObject_GetItem(cpy_r_r512, cpy_r_r557); CPy_DECREF(cpy_r_r512); CPy_DECREF(cpy_r_r557); @@ -79916,8 +82910,8 @@ CPyL58: ; if (!cpy_r_r109) goto CPyL61; CPy_Unreachable(); CPyL60: ; - tuple_T3OOO __tmp228 = { NULL, NULL, NULL }; - cpy_r_r110 = __tmp228; + tuple_T3OOO __tmp235 = { NULL, NULL, NULL }; + cpy_r_r110 = __tmp235; cpy_r_r111 = cpy_r_r110; goto CPyL62; CPyL61: ; @@ -80065,43 +83059,43 @@ PyObject *CPyPy_request_caching_validation___is_beyond_validation_threshold(PyOb PyObject *arg_blocknum; if (obj_blocknum == NULL) { arg_blocknum = NULL; - goto __LL229; + goto __LL236; } if (PyLong_Check(obj_blocknum)) arg_blocknum = obj_blocknum; else { arg_blocknum = NULL; } - if (arg_blocknum != NULL) goto __LL229; + if (arg_blocknum != NULL) goto __LL236; if (obj_blocknum == Py_None) arg_blocknum = obj_blocknum; else { arg_blocknum = NULL; } - if (arg_blocknum != NULL) goto __LL229; + if (arg_blocknum != NULL) goto __LL236; CPy_TypeError("int or None", obj_blocknum); goto fail; -__LL229: ; +__LL236: ; PyObject *arg_block_timestamp; if (obj_block_timestamp == NULL) { arg_block_timestamp = NULL; - goto __LL230; + goto __LL237; } if (PyLong_Check(obj_block_timestamp)) arg_block_timestamp = obj_block_timestamp; else { arg_block_timestamp = NULL; } - if (arg_block_timestamp != NULL) goto __LL230; + if (arg_block_timestamp != NULL) goto __LL237; if (obj_block_timestamp == Py_None) arg_block_timestamp = obj_block_timestamp; else { arg_block_timestamp = NULL; } - if (arg_block_timestamp != NULL) goto __LL230; + if (arg_block_timestamp != NULL) goto __LL237; CPy_TypeError("int or None", obj_block_timestamp); goto fail; -__LL230: ; +__LL237: ; char retval = CPyDef_request_caching_validation___is_beyond_validation_threshold(arg_provider, arg_blocknum, arg_block_timestamp); if (retval == 2) { return NULL; @@ -80580,8 +83574,8 @@ CPyL37: ; if (!cpy_r_r81) goto CPyL40; CPy_Unreachable(); CPyL39: ; - tuple_T3OOO __tmp231 = { NULL, NULL, NULL }; - cpy_r_r82 = __tmp231; + tuple_T3OOO __tmp238 = { NULL, NULL, NULL }; + cpy_r_r82 = __tmp238; cpy_r_r83 = cpy_r_r82; goto CPyL41; CPyL40: ; @@ -80930,8 +83924,8 @@ CPyL23: ; if (!cpy_r_r49) goto CPyL26; CPy_Unreachable(); CPyL25: ; - tuple_T3OOO __tmp232 = { NULL, NULL, NULL }; - cpy_r_r50 = __tmp232; + tuple_T3OOO __tmp239 = { NULL, NULL, NULL }; + cpy_r_r50 = __tmp239; cpy_r_r51 = cpy_r_r50; goto CPyL27; CPyL26: ; @@ -82218,8 +85212,8 @@ CPyL140: ; if (!cpy_r_r197) goto CPyL143; CPy_Unreachable(); CPyL142: ; - tuple_T3OOO __tmp233 = { NULL, NULL, NULL }; - cpy_r_r198 = __tmp233; + tuple_T3OOO __tmp240 = { NULL, NULL, NULL }; + cpy_r_r198 = __tmp240; cpy_r_r199 = cpy_r_r198; goto CPyL145; CPyL143: ; @@ -82642,10 +85636,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp234 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp234); - PyObject *__tmp235 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp235); + PyObject *__tmp241 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp241); + PyObject *__tmp242 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp242); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -82824,43 +85818,43 @@ PyObject *CPyPy_request_caching_validation___async_is_beyond_validation_threshol PyObject *arg_blocknum; if (obj_blocknum == NULL) { arg_blocknum = NULL; - goto __LL236; + goto __LL243; } if (PyLong_Check(obj_blocknum)) arg_blocknum = obj_blocknum; else { arg_blocknum = NULL; } - if (arg_blocknum != NULL) goto __LL236; + if (arg_blocknum != NULL) goto __LL243; if (obj_blocknum == Py_None) arg_blocknum = obj_blocknum; else { arg_blocknum = NULL; } - if (arg_blocknum != NULL) goto __LL236; + if (arg_blocknum != NULL) goto __LL243; CPy_TypeError("int or None", obj_blocknum); goto fail; -__LL236: ; +__LL243: ; PyObject *arg_block_timestamp; if (obj_block_timestamp == NULL) { arg_block_timestamp = NULL; - goto __LL237; + goto __LL244; } if (PyLong_Check(obj_block_timestamp)) arg_block_timestamp = obj_block_timestamp; else { arg_block_timestamp = NULL; } - if (arg_block_timestamp != NULL) goto __LL237; + if (arg_block_timestamp != NULL) goto __LL244; if (obj_block_timestamp == Py_None) arg_block_timestamp = obj_block_timestamp; else { arg_block_timestamp = NULL; } - if (arg_block_timestamp != NULL) goto __LL237; + if (arg_block_timestamp != NULL) goto __LL244; CPy_TypeError("int or None", obj_block_timestamp); goto fail; -__LL237: ; +__LL244: ; PyObject *retval = CPyDef_request_caching_validation___async_is_beyond_validation_threshold(arg_provider, arg_blocknum, arg_block_timestamp); return retval; fail: ; @@ -83500,10 +86494,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp238 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp238); - PyObject *__tmp239 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp239); + PyObject *__tmp245 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp245); + PyObject *__tmp246 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp246); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -84900,8 +87894,8 @@ CPyL148: ; if (!cpy_r_r203) goto CPyL151; CPy_Unreachable(); CPyL150: ; - tuple_T3OOO __tmp240 = { NULL, NULL, NULL }; - cpy_r_r204 = __tmp240; + tuple_T3OOO __tmp247 = { NULL, NULL, NULL }; + cpy_r_r204 = __tmp247; cpy_r_r205 = cpy_r_r204; goto CPyL153; CPyL151: ; @@ -85372,10 +88366,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp241 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp241); - PyObject *__tmp242 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp242); + PyObject *__tmp248 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp248); + PyObject *__tmp249 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp249); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -86347,8 +89341,8 @@ CPyL98: ; if (!cpy_r_r129) goto CPyL101; CPy_Unreachable(); CPyL100: ; - tuple_T3OOO __tmp243 = { NULL, NULL, NULL }; - cpy_r_r130 = __tmp243; + tuple_T3OOO __tmp250 = { NULL, NULL, NULL }; + cpy_r_r130 = __tmp250; cpy_r_r131 = cpy_r_r130; goto CPyL103; CPyL101: ; @@ -86752,10 +89746,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp244 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp244); - PyObject *__tmp245 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp245); + PyObject *__tmp251 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp251); + PyObject *__tmp252 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp252); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -87794,8 +90788,8 @@ CPyL2: ; cpy_r_r2 = PyTuple_New(1); if (unlikely(cpy_r_r2 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp246 = cpy_r_bases.f0; - PyTuple_SET_ITEM(cpy_r_r2, 0, __tmp246); + PyObject *__tmp253 = cpy_r_bases.f0; + PyTuple_SET_ITEM(cpy_r_r2, 0, __tmp253); cpy_r_r3 = PyObject_GetIter(cpy_r_r2); CPy_DECREF(cpy_r_r2); if (unlikely(cpy_r_r3 == NULL)) { @@ -88045,8 +91039,8 @@ CPyL45: ; cpy_r_r63 = PyTuple_New(1); if (unlikely(cpy_r_r63 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp247 = cpy_r_bases.f0; - PyTuple_SET_ITEM(cpy_r_r63, 0, __tmp247); + PyObject *__tmp254 = cpy_r_bases.f0; + PyTuple_SET_ITEM(cpy_r_r63, 0, __tmp254); PyObject *cpy_r_r64[5] = { cpy_r_r61, cpy_r_mcs, cpy_r_name, cpy_r_r63, cpy_r_processed_namespace @@ -88176,22 +91170,22 @@ PyObject *CPyPy_datatypes_____new___3_PropertyCheckingFactory_obj_____call__(PyO goto fail; } tuple_T1O arg_bases; - PyObject *__tmp248; + PyObject *__tmp255; if (unlikely(!(PyTuple_Check(obj_bases) && PyTuple_GET_SIZE(obj_bases) == 1))) { - __tmp248 = NULL; - goto __LL249; - } - __tmp248 = PyTuple_GET_ITEM(obj_bases, 0); - if (__tmp248 == NULL) goto __LL249; - __tmp248 = obj_bases; -__LL249: ; - if (unlikely(__tmp248 == NULL)) { + __tmp255 = NULL; + goto __LL256; + } + __tmp255 = PyTuple_GET_ITEM(obj_bases, 0); + if (__tmp255 == NULL) goto __LL256; + __tmp255 = obj_bases; +__LL256: ; + if (unlikely(__tmp255 == NULL)) { CPy_TypeError("tuple[object]", obj_bases); goto fail; } else { - PyObject *__tmp250 = PyTuple_GET_ITEM(obj_bases, 0); - PyObject *__tmp251; - __tmp251 = __tmp250; - arg_bases.f0 = __tmp251; + PyObject *__tmp257 = PyTuple_GET_ITEM(obj_bases, 0); + PyObject *__tmp258; + __tmp258 = __tmp257; + arg_bases.f0 = __tmp258; } PyObject *arg_namespace; if (likely(PyDict_Check(obj_namespace))) @@ -88203,23 +91197,23 @@ __LL249: ; PyObject *arg_normalizers; if (obj_normalizers == NULL) { arg_normalizers = NULL; - goto __LL252; + goto __LL259; } if (PyDict_Check(obj_normalizers)) arg_normalizers = obj_normalizers; else { arg_normalizers = NULL; } - if (arg_normalizers != NULL) goto __LL252; + if (arg_normalizers != NULL) goto __LL259; if (obj_normalizers == Py_None) arg_normalizers = obj_normalizers; else { arg_normalizers = NULL; } - if (arg_normalizers != NULL) goto __LL252; + if (arg_normalizers != NULL) goto __LL259; CPy_TypeError("dict or None", obj_normalizers); goto fail; -__LL252: ; +__LL259: ; PyObject *retval = CPyDef_datatypes_____new___3_PropertyCheckingFactory_obj_____call__(arg___mypyc_self__, arg_mcs, arg_name, arg_bases, arg_namespace, arg_normalizers); return retval; fail: ; @@ -89564,10 +92558,10 @@ CPyL19: ; cpy_r_r39 = PyTuple_New(2); if (unlikely(cpy_r_r39 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp253 = cpy_r_r38.f0; - PyTuple_SET_ITEM(cpy_r_r39, 0, __tmp253); - PyObject *__tmp254 = cpy_r_r38.f1; - PyTuple_SET_ITEM(cpy_r_r39, 1, __tmp254); + PyObject *__tmp260 = cpy_r_r38.f0; + PyTuple_SET_ITEM(cpy_r_r39, 0, __tmp260); + PyObject *__tmp261 = cpy_r_r38.f1; + PyTuple_SET_ITEM(cpy_r_r39, 1, __tmp261); cpy_r_r40 = PyObject_IsInstance(cpy_r_val, cpy_r_r39); CPy_DECREF(cpy_r_r39); cpy_r_r41 = cpy_r_r40 >= 0; @@ -89663,18 +92657,18 @@ PyObject *CPyPy_type_conversion___to_hex_if_bytes(PyObject *self, PyObject *cons else { arg_val = NULL; } - if (arg_val != NULL) goto __LL255; + if (arg_val != NULL) goto __LL262; if (PyBytes_Check(obj_val) || PyByteArray_Check(obj_val)) arg_val = obj_val; else { arg_val = NULL; } - if (arg_val != NULL) goto __LL255; + if (arg_val != NULL) goto __LL262; arg_val = obj_val; - if (arg_val != NULL) goto __LL255; + if (arg_val != NULL) goto __LL262; CPy_TypeError("union[str, bytes, object]", obj_val); goto fail; -__LL255: ; +__LL262: ; PyObject *retval = CPyDef_type_conversion___to_hex_if_bytes(arg_val); return retval; fail: ; @@ -89769,18 +92763,18 @@ PyObject *CPyPy_type_conversion___to_bytes_if_hex(PyObject *self, PyObject *cons else { arg_val = NULL; } - if (arg_val != NULL) goto __LL256; + if (arg_val != NULL) goto __LL263; if (PyBytes_Check(obj_val) || PyByteArray_Check(obj_val)) arg_val = obj_val; else { arg_val = NULL; } - if (arg_val != NULL) goto __LL256; + if (arg_val != NULL) goto __LL263; arg_val = obj_val; - if (arg_val != NULL) goto __LL256; + if (arg_val != NULL) goto __LL263; CPy_TypeError("union[str, bytes, object]", obj_val); goto fail; -__LL256: ; +__LL263: ; PyObject *retval = CPyDef_type_conversion___to_bytes_if_hex(arg_val); return retval; fail: ; @@ -90076,16 +93070,16 @@ PyObject *CPyPy_utility_methods___all_in_dict(PyObject *self, PyObject *const *a PyObject *arg_values = obj_values; PyObject *arg_d; arg_d = obj_d; - if (arg_d != NULL) goto __LL257; + if (arg_d != NULL) goto __LL264; if (PyDict_Check(obj_d)) arg_d = obj_d; else { arg_d = NULL; } - if (arg_d != NULL) goto __LL257; + if (arg_d != NULL) goto __LL264; CPy_TypeError("union[object, dict]", obj_d); goto fail; -__LL257: ; +__LL264: ; char retval = CPyDef_utility_methods___all_in_dict(arg_values, arg_d); if (retval == 2) { return NULL; @@ -90191,16 +93185,16 @@ PyObject *CPyPy_utility_methods___any_in_dict(PyObject *self, PyObject *const *a PyObject *arg_values = obj_values; PyObject *arg_d; arg_d = obj_d; - if (arg_d != NULL) goto __LL258; + if (arg_d != NULL) goto __LL265; if (PyDict_Check(obj_d)) arg_d = obj_d; else { arg_d = NULL; } - if (arg_d != NULL) goto __LL258; + if (arg_d != NULL) goto __LL265; CPy_TypeError("union[object, dict]", obj_d); goto fail; -__LL258: ; +__LL265: ; char retval = CPyDef_utility_methods___any_in_dict(arg_values, arg_d); if (retval == 2) { return NULL; @@ -90240,16 +93234,16 @@ PyObject *CPyPy_utility_methods___none_in_dict(PyObject *self, PyObject *const * PyObject *arg_values = obj_values; PyObject *arg_d; arg_d = obj_d; - if (arg_d != NULL) goto __LL259; + if (arg_d != NULL) goto __LL266; if (PyDict_Check(obj_d)) arg_d = obj_d; else { arg_d = NULL; } - if (arg_d != NULL) goto __LL259; + if (arg_d != NULL) goto __LL266; CPy_TypeError("union[object, dict]", obj_d); goto fail; -__LL259: ; +__LL266: ; char retval = CPyDef_utility_methods___none_in_dict(arg_values, arg_d); if (retval == 2) { return NULL; @@ -91314,23 +94308,23 @@ PyObject *CPyPy_rpc___rpc_gas_price_strategy(PyObject *self, PyObject *const *ar PyObject *arg_transaction_params; if (obj_transaction_params == NULL) { arg_transaction_params = NULL; - goto __LL260; + goto __LL267; } if (PyDict_Check(obj_transaction_params)) arg_transaction_params = obj_transaction_params; else { arg_transaction_params = NULL; } - if (arg_transaction_params != NULL) goto __LL260; + if (arg_transaction_params != NULL) goto __LL267; if (obj_transaction_params == Py_None) arg_transaction_params = obj_transaction_params; else { arg_transaction_params = NULL; } - if (arg_transaction_params != NULL) goto __LL260; + if (arg_transaction_params != NULL) goto __LL267; CPy_TypeError("dict or None", obj_transaction_params); goto fail; -__LL260: ; +__LL267: ; CPyTagged retval = CPyDef_rpc___rpc_gas_price_strategy(arg_w3, arg_transaction_params); if (retval == CPY_INT_TAG) { return NULL; @@ -93544,12 +96538,12 @@ CPyL24: ; cpy_r_r39 = PyTuple_New(3); if (unlikely(cpy_r_r39 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp261 = cpy_r_r38.f0; - PyTuple_SET_ITEM(cpy_r_r39, 0, __tmp261); - PyObject *__tmp262 = cpy_r_r38.f1; - PyTuple_SET_ITEM(cpy_r_r39, 1, __tmp262); - PyObject *__tmp263 = cpy_r_r38.f2; - PyTuple_SET_ITEM(cpy_r_r39, 2, __tmp263); + PyObject *__tmp268 = cpy_r_r38.f0; + PyTuple_SET_ITEM(cpy_r_r39, 0, __tmp268); + PyObject *__tmp269 = cpy_r_r38.f1; + PyTuple_SET_ITEM(cpy_r_r39, 1, __tmp269); + PyObject *__tmp270 = cpy_r_r38.f2; + PyTuple_SET_ITEM(cpy_r_r39, 2, __tmp270); ((faster_web3___gas_strategies___time_based____get_raw_miner_data_genObject *)cpy_r___mypyc_self__)->___mypyc_next_label__ = 1; return cpy_r_r39; CPyL27: ; @@ -93854,12 +96848,12 @@ CPyL74: ; cpy_r_r112 = PyTuple_New(3); if (unlikely(cpy_r_r112 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp264 = cpy_r_r111.f0; - PyTuple_SET_ITEM(cpy_r_r112, 0, __tmp264); - PyObject *__tmp265 = cpy_r_r111.f1; - PyTuple_SET_ITEM(cpy_r_r112, 1, __tmp265); - PyObject *__tmp266 = cpy_r_r111.f2; - PyTuple_SET_ITEM(cpy_r_r112, 2, __tmp266); + PyObject *__tmp271 = cpy_r_r111.f0; + PyTuple_SET_ITEM(cpy_r_r112, 0, __tmp271); + PyObject *__tmp272 = cpy_r_r111.f1; + PyTuple_SET_ITEM(cpy_r_r112, 1, __tmp272); + PyObject *__tmp273 = cpy_r_r111.f2; + PyTuple_SET_ITEM(cpy_r_r112, 2, __tmp273); ((faster_web3___gas_strategies___time_based____get_raw_miner_data_genObject *)cpy_r___mypyc_self__)->___mypyc_next_label__ = 2; return cpy_r_r112; CPyL77: ; @@ -94177,10 +97171,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp267 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp267); - PyObject *__tmp268 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp268); + PyObject *__tmp274 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp274); + PyObject *__tmp275 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp275); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -95262,10 +98256,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp269 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp269); - PyObject *__tmp270 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp270); + PyObject *__tmp276 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp276); + PyObject *__tmp277 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp277); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -96212,10 +99206,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp271 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp271); - PyObject *__tmp272 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp272); + PyObject *__tmp278 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp278); + PyObject *__tmp279 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp279); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -97420,16 +100414,16 @@ PyObject *CPyPy_time_based___time_based_gas_price_strategy_construct_time_based_ else { arg_transaction_params = NULL; } - if (arg_transaction_params != NULL) goto __LL273; + if (arg_transaction_params != NULL) goto __LL280; if (obj_transaction_params == Py_None) arg_transaction_params = obj_transaction_params; else { arg_transaction_params = NULL; } - if (arg_transaction_params != NULL) goto __LL273; + if (arg_transaction_params != NULL) goto __LL280; CPy_TypeError("dict or None", obj_transaction_params); goto fail; -__LL273: ; +__LL280: ; CPyTagged retval = CPyDef_time_based___time_based_gas_price_strategy_construct_time_based_gas_price_strategy_obj_____call__(arg___mypyc_self__, arg_w3, arg_transaction_params); if (retval == CPY_INT_TAG) { return NULL; @@ -99592,8 +102586,8 @@ CPyL63: ; if (!cpy_r_r110) goto CPyL66; CPy_Unreachable(); CPyL65: ; - tuple_T3OOO __tmp274 = { NULL, NULL, NULL }; - cpy_r_r111 = __tmp274; + tuple_T3OOO __tmp281 = { NULL, NULL, NULL }; + cpy_r_r111 = __tmp281; cpy_r_r112 = cpy_r_r111; goto CPyL67; CPyL66: ; @@ -99909,8 +102903,8 @@ CPyL113: ; if (!cpy_r_r165) goto CPyL116; CPy_Unreachable(); CPyL115: ; - tuple_T3OOO __tmp275 = { NULL, NULL, NULL }; - cpy_r_r166 = __tmp275; + tuple_T3OOO __tmp282 = { NULL, NULL, NULL }; + cpy_r_r166 = __tmp282; cpy_r_r167 = cpy_r_r166; goto CPyL117; CPyL116: ; @@ -100324,10 +103318,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp276 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp276); - PyObject *__tmp277 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp277); + PyObject *__tmp283 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp283); + PyObject *__tmp284 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp284); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -100481,10 +103475,10 @@ PyObject *CPyDef_node___GethBenchmarkFixture____rpc_port(PyObject *cpy_r_self) { cpy_r_r7 = PyTuple_New(2); if (unlikely(cpy_r_r7 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp278 = cpy_r_r5.f0; - PyTuple_SET_ITEM(cpy_r_r7, 0, __tmp278); - PyObject *__tmp279 = CPyTagged_StealAsObject(cpy_r_r5.f1); - PyTuple_SET_ITEM(cpy_r_r7, 1, __tmp279); + PyObject *__tmp285 = cpy_r_r5.f0; + PyTuple_SET_ITEM(cpy_r_r7, 0, __tmp285); + PyObject *__tmp286 = CPyTagged_StealAsObject(cpy_r_r5.f1); + PyTuple_SET_ITEM(cpy_r_r7, 1, __tmp286); PyObject *cpy_r_r8[2] = {cpy_r_r3, cpy_r_r7}; cpy_r_r9 = (PyObject **)&cpy_r_r8; cpy_r_r10 = PyObject_VectorcallMethod(cpy_r_r6, cpy_r_r9, 9223372036854775810ULL, 0); @@ -101028,36 +104022,36 @@ CPyL2: ; cpy_r_r25 = PyTuple_New(15); if (unlikely(cpy_r_r25 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp280 = cpy_r_r24.f0; - PyTuple_SET_ITEM(cpy_r_r25, 0, __tmp280); - PyObject *__tmp281 = cpy_r_r24.f1; - PyTuple_SET_ITEM(cpy_r_r25, 1, __tmp281); - PyObject *__tmp282 = cpy_r_r24.f2; - PyTuple_SET_ITEM(cpy_r_r25, 2, __tmp282); - PyObject *__tmp283 = cpy_r_r24.f3; - PyTuple_SET_ITEM(cpy_r_r25, 3, __tmp283); - PyObject *__tmp284 = cpy_r_r24.f4; - PyTuple_SET_ITEM(cpy_r_r25, 4, __tmp284); - PyObject *__tmp285 = cpy_r_r24.f5; - PyTuple_SET_ITEM(cpy_r_r25, 5, __tmp285); - PyObject *__tmp286 = cpy_r_r24.f6; - PyTuple_SET_ITEM(cpy_r_r25, 6, __tmp286); - PyObject *__tmp287 = cpy_r_r24.f7; - PyTuple_SET_ITEM(cpy_r_r25, 7, __tmp287); - PyObject *__tmp288 = cpy_r_r24.f8; - PyTuple_SET_ITEM(cpy_r_r25, 8, __tmp288); - PyObject *__tmp289 = cpy_r_r24.f9; - PyTuple_SET_ITEM(cpy_r_r25, 9, __tmp289); - PyObject *__tmp290 = cpy_r_r24.f10; - PyTuple_SET_ITEM(cpy_r_r25, 10, __tmp290); - PyObject *__tmp291 = cpy_r_r24.f11; - PyTuple_SET_ITEM(cpy_r_r25, 11, __tmp291); - PyObject *__tmp292 = cpy_r_r24.f12; - PyTuple_SET_ITEM(cpy_r_r25, 12, __tmp292); - PyObject *__tmp293 = cpy_r_r24.f13; - PyTuple_SET_ITEM(cpy_r_r25, 13, __tmp293); - PyObject *__tmp294 = cpy_r_r24.f14; - PyTuple_SET_ITEM(cpy_r_r25, 14, __tmp294); + PyObject *__tmp287 = cpy_r_r24.f0; + PyTuple_SET_ITEM(cpy_r_r25, 0, __tmp287); + PyObject *__tmp288 = cpy_r_r24.f1; + PyTuple_SET_ITEM(cpy_r_r25, 1, __tmp288); + PyObject *__tmp289 = cpy_r_r24.f2; + PyTuple_SET_ITEM(cpy_r_r25, 2, __tmp289); + PyObject *__tmp290 = cpy_r_r24.f3; + PyTuple_SET_ITEM(cpy_r_r25, 3, __tmp290); + PyObject *__tmp291 = cpy_r_r24.f4; + PyTuple_SET_ITEM(cpy_r_r25, 4, __tmp291); + PyObject *__tmp292 = cpy_r_r24.f5; + PyTuple_SET_ITEM(cpy_r_r25, 5, __tmp292); + PyObject *__tmp293 = cpy_r_r24.f6; + PyTuple_SET_ITEM(cpy_r_r25, 6, __tmp293); + PyObject *__tmp294 = cpy_r_r24.f7; + PyTuple_SET_ITEM(cpy_r_r25, 7, __tmp294); + PyObject *__tmp295 = cpy_r_r24.f8; + PyTuple_SET_ITEM(cpy_r_r25, 8, __tmp295); + PyObject *__tmp296 = cpy_r_r24.f9; + PyTuple_SET_ITEM(cpy_r_r25, 9, __tmp296); + PyObject *__tmp297 = cpy_r_r24.f10; + PyTuple_SET_ITEM(cpy_r_r25, 10, __tmp297); + PyObject *__tmp298 = cpy_r_r24.f11; + PyTuple_SET_ITEM(cpy_r_r25, 11, __tmp298); + PyObject *__tmp299 = cpy_r_r24.f12; + PyTuple_SET_ITEM(cpy_r_r25, 12, __tmp299); + PyObject *__tmp300 = cpy_r_r24.f13; + PyTuple_SET_ITEM(cpy_r_r25, 13, __tmp300); + PyObject *__tmp301 = cpy_r_r24.f14; + PyTuple_SET_ITEM(cpy_r_r25, 14, __tmp301); return cpy_r_r25; CPyL7: ; cpy_r_r26 = NULL; @@ -101308,16 +104302,16 @@ CPyL12: ; cpy_r_r25 = PyTuple_New(5); if (unlikely(cpy_r_r25 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp295 = cpy_r_r13.f0; - PyTuple_SET_ITEM(cpy_r_r25, 0, __tmp295); - PyObject *__tmp296 = cpy_r_r13.f1; - PyTuple_SET_ITEM(cpy_r_r25, 1, __tmp296); - PyObject *__tmp297 = cpy_r_r13.f2; - PyTuple_SET_ITEM(cpy_r_r25, 2, __tmp297); - PyObject *__tmp298 = cpy_r_r13.f3; - PyTuple_SET_ITEM(cpy_r_r25, 3, __tmp298); - PyObject *__tmp299 = cpy_r_r13.f4; - PyTuple_SET_ITEM(cpy_r_r25, 4, __tmp299); + PyObject *__tmp302 = cpy_r_r13.f0; + PyTuple_SET_ITEM(cpy_r_r25, 0, __tmp302); + PyObject *__tmp303 = cpy_r_r13.f1; + PyTuple_SET_ITEM(cpy_r_r25, 1, __tmp303); + PyObject *__tmp304 = cpy_r_r13.f2; + PyTuple_SET_ITEM(cpy_r_r25, 2, __tmp304); + PyObject *__tmp305 = cpy_r_r13.f3; + PyTuple_SET_ITEM(cpy_r_r25, 3, __tmp305); + PyObject *__tmp306 = cpy_r_r13.f4; + PyTuple_SET_ITEM(cpy_r_r25, 4, __tmp306); cpy_r_r26 = CPyTagged_StealAsObject(cpy_r_r17); cpy_r_r27 = CPyTagged_StealAsObject(cpy_r_r21); PyObject *cpy_r_r28[3] = {cpy_r_r25, cpy_r_r26, cpy_r_r27}; @@ -101458,8 +104452,8 @@ CPyL32: ; } CPy_Unreachable(); CPyL35: ; - tuple_T3OOO __tmp300 = { NULL, NULL, NULL }; - cpy_r_r62 = __tmp300; + tuple_T3OOO __tmp307 = { NULL, NULL, NULL }; + cpy_r_r62 = __tmp307; cpy_r_r63 = cpy_r_r62; goto CPyL37; CPyL36: ; @@ -101793,10 +104787,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp301 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp301); - PyObject *__tmp302 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp302); + PyObject *__tmp308 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp308); + PyObject *__tmp309 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp309); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -103750,8 +106744,8 @@ PyObject *CPyDef_benchmark___utils___wait_for_aiohttp_gen_____mypyc_generator_he cpy_r_r5 = cpy_r_r4; cpy_r_r6 = NULL; cpy_r_r7 = cpy_r_r6; - tuple_T3OOO __tmp303 = { NULL, NULL, NULL }; - cpy_r_r8 = __tmp303; + tuple_T3OOO __tmp310 = { NULL, NULL, NULL }; + cpy_r_r8 = __tmp310; cpy_r_r9 = cpy_r_r8; cpy_r_r10 = NULL; cpy_r_r11 = cpy_r_r10; @@ -104557,8 +107551,8 @@ CPyL127: ; if (!cpy_r_r153) goto CPyL130; CPy_Unreachable(); CPyL129: ; - tuple_T3OOO __tmp304 = { NULL, NULL, NULL }; - cpy_r_r154 = __tmp304; + tuple_T3OOO __tmp311 = { NULL, NULL, NULL }; + cpy_r_r154 = __tmp311; cpy_r_r9 = cpy_r_r154; goto CPyL131; CPyL130: ; @@ -105509,10 +108503,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp305 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp305); - PyObject *__tmp306 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp306); + PyObject *__tmp312 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp312); + PyObject *__tmp313 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp313); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -106957,39 +109951,39 @@ CPyL11: ; goto CPyL22; } CPy_DECREF(cpy_r_r17); - PyObject *__tmp307; + PyObject *__tmp314; if (unlikely(!(PyTuple_Check(cpy_r_r23) && PyTuple_GET_SIZE(cpy_r_r23) == 2))) { - __tmp307 = NULL; - goto __LL308; + __tmp314 = NULL; + goto __LL315; } if (likely(PyUnicode_Check(PyTuple_GET_ITEM(cpy_r_r23, 0)))) - __tmp307 = PyTuple_GET_ITEM(cpy_r_r23, 0); + __tmp314 = PyTuple_GET_ITEM(cpy_r_r23, 0); else { - __tmp307 = NULL; + __tmp314 = NULL; } - if (__tmp307 == NULL) goto __LL308; - __tmp307 = PyTuple_GET_ITEM(cpy_r_r23, 1); - if (__tmp307 == NULL) goto __LL308; - __tmp307 = cpy_r_r23; -__LL308: ; - if (unlikely(__tmp307 == NULL)) { + if (__tmp314 == NULL) goto __LL315; + __tmp314 = PyTuple_GET_ITEM(cpy_r_r23, 1); + if (__tmp314 == NULL) goto __LL315; + __tmp314 = cpy_r_r23; +__LL315: ; + if (unlikely(__tmp314 == NULL)) { CPy_TypeError("tuple[str, object]", cpy_r_r23); cpy_r_r24 = (tuple_T2OO) { NULL, NULL }; } else { - PyObject *__tmp309 = PyTuple_GET_ITEM(cpy_r_r23, 0); - CPy_INCREF(__tmp309); - PyObject *__tmp310; - if (likely(PyUnicode_Check(__tmp309))) - __tmp310 = __tmp309; + PyObject *__tmp316 = PyTuple_GET_ITEM(cpy_r_r23, 0); + CPy_INCREF(__tmp316); + PyObject *__tmp317; + if (likely(PyUnicode_Check(__tmp316))) + __tmp317 = __tmp316; else { - CPy_TypeError("str", __tmp309); - __tmp310 = NULL; + CPy_TypeError("str", __tmp316); + __tmp317 = NULL; } - cpy_r_r24.f0 = __tmp310; - PyObject *__tmp311 = PyTuple_GET_ITEM(cpy_r_r23, 1); - CPy_INCREF(__tmp311); - PyObject *__tmp312; - __tmp312 = __tmp311; - cpy_r_r24.f1 = __tmp312; + cpy_r_r24.f0 = __tmp317; + PyObject *__tmp318 = PyTuple_GET_ITEM(cpy_r_r23, 1); + CPy_INCREF(__tmp318); + PyObject *__tmp319; + __tmp319 = __tmp318; + cpy_r_r24.f1 = __tmp319; } CPy_DECREF(cpy_r_r23); if (unlikely(cpy_r_r24.f0 == NULL)) { @@ -107039,8 +110033,8 @@ CPyL19: ; cpy_r_r39.f1 = cpy_r_r37; return cpy_r_r39; CPyL20: ; - tuple_T2OO __tmp313 = { NULL, NULL }; - cpy_r_r40 = __tmp313; + tuple_T2OO __tmp320 = { NULL, NULL }; + cpy_r_r40 = __tmp320; return cpy_r_r40; CPyL21: ; CPy_DecRef(cpy_r_r0); @@ -107085,10 +110079,10 @@ PyObject *CPyPy_utils___caching___SimpleCache___cache(PyObject *self, PyObject * PyObject *retbox = PyTuple_New(2); if (unlikely(retbox == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp314 = retval.f0; - PyTuple_SET_ITEM(retbox, 0, __tmp314); - PyObject *__tmp315 = retval.f1; - PyTuple_SET_ITEM(retbox, 1, __tmp315); + PyObject *__tmp321 = retval.f0; + PyTuple_SET_ITEM(retbox, 0, __tmp321); + PyObject *__tmp322 = retval.f1; + PyTuple_SET_ITEM(retbox, 1, __tmp322); return retbox; fail: ; CPy_AddTraceback("faster_web3/utils/caching.py", "cache", DIFFCHECK_PLACEHOLDER, CPyStatic_utils___caching___globals); @@ -107384,39 +110378,39 @@ CPyL3: ; goto CPyL7; } CPy_DECREF(cpy_r_r0); - PyObject *__tmp316; + PyObject *__tmp323; if (unlikely(!(PyTuple_Check(cpy_r_r6) && PyTuple_GET_SIZE(cpy_r_r6) == 2))) { - __tmp316 = NULL; - goto __LL317; + __tmp323 = NULL; + goto __LL324; } if (likely(PyUnicode_Check(PyTuple_GET_ITEM(cpy_r_r6, 0)))) - __tmp316 = PyTuple_GET_ITEM(cpy_r_r6, 0); + __tmp323 = PyTuple_GET_ITEM(cpy_r_r6, 0); else { - __tmp316 = NULL; + __tmp323 = NULL; } - if (__tmp316 == NULL) goto __LL317; - __tmp316 = PyTuple_GET_ITEM(cpy_r_r6, 1); - if (__tmp316 == NULL) goto __LL317; - __tmp316 = cpy_r_r6; -__LL317: ; - if (unlikely(__tmp316 == NULL)) { + if (__tmp323 == NULL) goto __LL324; + __tmp323 = PyTuple_GET_ITEM(cpy_r_r6, 1); + if (__tmp323 == NULL) goto __LL324; + __tmp323 = cpy_r_r6; +__LL324: ; + if (unlikely(__tmp323 == NULL)) { CPy_TypeError("tuple[str, object]", cpy_r_r6); cpy_r_r7 = (tuple_T2OO) { NULL, NULL }; } else { - PyObject *__tmp318 = PyTuple_GET_ITEM(cpy_r_r6, 0); - CPy_INCREF(__tmp318); - PyObject *__tmp319; - if (likely(PyUnicode_Check(__tmp318))) - __tmp319 = __tmp318; + PyObject *__tmp325 = PyTuple_GET_ITEM(cpy_r_r6, 0); + CPy_INCREF(__tmp325); + PyObject *__tmp326; + if (likely(PyUnicode_Check(__tmp325))) + __tmp326 = __tmp325; else { - CPy_TypeError("str", __tmp318); - __tmp319 = NULL; + CPy_TypeError("str", __tmp325); + __tmp326 = NULL; } - cpy_r_r7.f0 = __tmp319; - PyObject *__tmp320 = PyTuple_GET_ITEM(cpy_r_r6, 1); - CPy_INCREF(__tmp320); - PyObject *__tmp321; - __tmp321 = __tmp320; - cpy_r_r7.f1 = __tmp321; + cpy_r_r7.f0 = __tmp326; + PyObject *__tmp327 = PyTuple_GET_ITEM(cpy_r_r6, 1); + CPy_INCREF(__tmp327); + PyObject *__tmp328; + __tmp328 = __tmp327; + cpy_r_r7.f1 = __tmp328; } CPy_DECREF(cpy_r_r6); if (unlikely(cpy_r_r7.f0 == NULL)) { @@ -107425,8 +110419,8 @@ __LL317: ; } return cpy_r_r7; CPyL6: ; - tuple_T2OO __tmp322 = { NULL, NULL }; - cpy_r_r8 = __tmp322; + tuple_T2OO __tmp329 = { NULL, NULL }; + cpy_r_r8 = __tmp329; return cpy_r_r8; CPyL7: ; CPy_DecRef(cpy_r_r0); @@ -107462,10 +110456,10 @@ PyObject *CPyPy_utils___caching___SimpleCache___popitem(PyObject *self, PyObject PyObject *retbox = PyTuple_New(2); if (unlikely(retbox == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp323 = retval.f0; - PyTuple_SET_ITEM(retbox, 0, __tmp323); - PyObject *__tmp324 = retval.f1; - PyTuple_SET_ITEM(retbox, 1, __tmp324); + PyObject *__tmp330 = retval.f0; + PyTuple_SET_ITEM(retbox, 0, __tmp330); + PyObject *__tmp331 = retval.f1; + PyTuple_SET_ITEM(retbox, 1, __tmp331); return retbox; fail: ; CPy_AddTraceback("faster_web3/utils/caching.py", "popitem", DIFFCHECK_PLACEHOLDER, CPyStatic_utils___caching___globals); @@ -107985,10 +110979,10 @@ CPyL47: ; cpy_r_r57 = PyTuple_New(2); if (unlikely(cpy_r_r57 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp325 = cpy_r_r56.f0; - PyTuple_SET_ITEM(cpy_r_r57, 0, __tmp325); - PyObject *__tmp326 = cpy_r_r56.f1; - PyTuple_SET_ITEM(cpy_r_r57, 1, __tmp326); + PyObject *__tmp332 = cpy_r_r56.f0; + PyTuple_SET_ITEM(cpy_r_r57, 0, __tmp332); + PyObject *__tmp333 = cpy_r_r56.f1; + PyTuple_SET_ITEM(cpy_r_r57, 1, __tmp333); ((faster_web3___utils___caching___async_await_and_popitem_SimpleCache_genObject *)cpy_r___mypyc_self__)->___mypyc_next_label__ = -1; if (cpy_r_stop_iter_ptr != NULL) goto CPyL52; CPyGen_SetStopIterationValue(cpy_r_r57); @@ -108664,10 +111658,10 @@ CPyL3: ; cpy_r_r11 = PyTuple_New(2); if (unlikely(cpy_r_r11 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp327 = cpy_r_r10.f0; - PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp327); - PyObject *__tmp328 = cpy_r_r10.f1; - PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp328); + PyObject *__tmp334 = cpy_r_r10.f0; + PyTuple_SET_ITEM(cpy_r_r11, 0, __tmp334); + PyObject *__tmp335 = cpy_r_r10.f1; + PyTuple_SET_ITEM(cpy_r_r11, 1, __tmp335); cpy_r_r12 = CPy_ExceptionMatches(cpy_r_r11); CPy_DECREF(cpy_r_r11); if (!cpy_r_r12) goto CPyL13; @@ -109557,10 +112551,10 @@ CPyL9: ; cpy_r_r44 = PyTuple_New(2); if (unlikely(cpy_r_r44 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp329 = cpy_r_r41.f0; - PyTuple_SET_ITEM(cpy_r_r44, 0, __tmp329); - PyObject *__tmp330 = cpy_r_r41.f1; - PyTuple_SET_ITEM(cpy_r_r44, 1, __tmp330); + PyObject *__tmp336 = cpy_r_r41.f0; + PyTuple_SET_ITEM(cpy_r_r44, 0, __tmp336); + PyObject *__tmp337 = cpy_r_r41.f1; + PyTuple_SET_ITEM(cpy_r_r44, 1, __tmp337); cpy_r_r45 = CPyDict_SetItem(cpy_r_r42, cpy_r_r43, cpy_r_r44); CPy_DECREF(cpy_r_r44); cpy_r_r46 = cpy_r_r45 >= 0; @@ -114501,10 +117495,10 @@ CPyL3: ; cpy_r_r38 = PyTuple_New(2); if (unlikely(cpy_r_r38 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp331 = cpy_r_r37.f0; - PyTuple_SET_ITEM(cpy_r_r38, 0, __tmp331); - PyObject *__tmp332 = cpy_r_r37.f1; - PyTuple_SET_ITEM(cpy_r_r38, 1, __tmp332); + PyObject *__tmp338 = cpy_r_r37.f0; + PyTuple_SET_ITEM(cpy_r_r38, 0, __tmp338); + PyObject *__tmp339 = cpy_r_r37.f1; + PyTuple_SET_ITEM(cpy_r_r38, 1, __tmp339); cpy_r_r39 = PyObject_GetItem(cpy_r_r32, cpy_r_r38); CPy_DECREF(cpy_r_r32); CPy_DECREF(cpy_r_r38); @@ -114638,16 +117632,16 @@ CPyL3: ; cpy_r_r93 = PyTuple_New(5); if (unlikely(cpy_r_r93 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp333 = cpy_r_r92.f0; - PyTuple_SET_ITEM(cpy_r_r93, 0, __tmp333); - PyObject *__tmp334 = cpy_r_r92.f1; - PyTuple_SET_ITEM(cpy_r_r93, 1, __tmp334); - PyObject *__tmp335 = cpy_r_r92.f2; - PyTuple_SET_ITEM(cpy_r_r93, 2, __tmp335); - PyObject *__tmp336 = cpy_r_r92.f3; - PyTuple_SET_ITEM(cpy_r_r93, 3, __tmp336); - PyObject *__tmp337 = cpy_r_r92.f4; - PyTuple_SET_ITEM(cpy_r_r93, 4, __tmp337); + PyObject *__tmp340 = cpy_r_r92.f0; + PyTuple_SET_ITEM(cpy_r_r93, 0, __tmp340); + PyObject *__tmp341 = cpy_r_r92.f1; + PyTuple_SET_ITEM(cpy_r_r93, 1, __tmp341); + PyObject *__tmp342 = cpy_r_r92.f2; + PyTuple_SET_ITEM(cpy_r_r93, 2, __tmp342); + PyObject *__tmp343 = cpy_r_r92.f3; + PyTuple_SET_ITEM(cpy_r_r93, 3, __tmp343); + PyObject *__tmp344 = cpy_r_r92.f4; + PyTuple_SET_ITEM(cpy_r_r93, 4, __tmp344); cpy_r_r94 = PyObject_GetItem(cpy_r_r86, cpy_r_r93); CPy_DECREF(cpy_r_r86); CPy_DECREF(cpy_r_r93); @@ -114717,18 +117711,18 @@ CPyL3: ; cpy_r_r119 = PyTuple_New(6); if (unlikely(cpy_r_r119 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp338 = cpy_r_r118.f0; - PyTuple_SET_ITEM(cpy_r_r119, 0, __tmp338); - PyObject *__tmp339 = cpy_r_r118.f1; - PyTuple_SET_ITEM(cpy_r_r119, 1, __tmp339); - PyObject *__tmp340 = cpy_r_r118.f2; - PyTuple_SET_ITEM(cpy_r_r119, 2, __tmp340); - PyObject *__tmp341 = cpy_r_r118.f3; - PyTuple_SET_ITEM(cpy_r_r119, 3, __tmp341); - PyObject *__tmp342 = cpy_r_r118.f4; - PyTuple_SET_ITEM(cpy_r_r119, 4, __tmp342); - PyObject *__tmp343 = cpy_r_r118.f5; - PyTuple_SET_ITEM(cpy_r_r119, 5, __tmp343); + PyObject *__tmp345 = cpy_r_r118.f0; + PyTuple_SET_ITEM(cpy_r_r119, 0, __tmp345); + PyObject *__tmp346 = cpy_r_r118.f1; + PyTuple_SET_ITEM(cpy_r_r119, 1, __tmp346); + PyObject *__tmp347 = cpy_r_r118.f2; + PyTuple_SET_ITEM(cpy_r_r119, 2, __tmp347); + PyObject *__tmp348 = cpy_r_r118.f3; + PyTuple_SET_ITEM(cpy_r_r119, 3, __tmp348); + PyObject *__tmp349 = cpy_r_r118.f4; + PyTuple_SET_ITEM(cpy_r_r119, 4, __tmp349); + PyObject *__tmp350 = cpy_r_r118.f5; + PyTuple_SET_ITEM(cpy_r_r119, 5, __tmp350); cpy_r_r120 = PyObject_GetItem(cpy_r_r101, cpy_r_r119); CPy_DECREF(cpy_r_r101); CPy_DECREF(cpy_r_r119); @@ -114825,12 +117819,12 @@ CPyL3: ; cpy_r_r153 = PyTuple_New(3); if (unlikely(cpy_r_r153 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp344 = cpy_r_r152.f0; - PyTuple_SET_ITEM(cpy_r_r153, 0, __tmp344); - PyObject *__tmp345 = cpy_r_r152.f1; - PyTuple_SET_ITEM(cpy_r_r153, 1, __tmp345); - PyObject *__tmp346 = cpy_r_r152.f2; - PyTuple_SET_ITEM(cpy_r_r153, 2, __tmp346); + PyObject *__tmp351 = cpy_r_r152.f0; + PyTuple_SET_ITEM(cpy_r_r153, 0, __tmp351); + PyObject *__tmp352 = cpy_r_r152.f1; + PyTuple_SET_ITEM(cpy_r_r153, 1, __tmp352); + PyObject *__tmp353 = cpy_r_r152.f2; + PyTuple_SET_ITEM(cpy_r_r153, 2, __tmp353); cpy_r_r154 = PyObject_GetItem(cpy_r_r136, cpy_r_r153); CPy_DECREF(cpy_r_r136); CPy_DECREF(cpy_r_r153); @@ -114881,12 +117875,12 @@ CPyL3: ; cpy_r_r172 = PyTuple_New(3); if (unlikely(cpy_r_r172 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp347 = cpy_r_r171.f0; - PyTuple_SET_ITEM(cpy_r_r172, 0, __tmp347); - PyObject *__tmp348 = cpy_r_r171.f1; - PyTuple_SET_ITEM(cpy_r_r172, 1, __tmp348); - PyObject *__tmp349 = cpy_r_r171.f2; - PyTuple_SET_ITEM(cpy_r_r172, 2, __tmp349); + PyObject *__tmp354 = cpy_r_r171.f0; + PyTuple_SET_ITEM(cpy_r_r172, 0, __tmp354); + PyObject *__tmp355 = cpy_r_r171.f1; + PyTuple_SET_ITEM(cpy_r_r172, 1, __tmp355); + PyObject *__tmp356 = cpy_r_r171.f2; + PyTuple_SET_ITEM(cpy_r_r172, 2, __tmp356); cpy_r_r173 = PyObject_GetItem(cpy_r_r161, cpy_r_r172); CPy_DECREF(cpy_r_r161); CPy_DECREF(cpy_r_r172); @@ -114945,10 +117939,10 @@ CPyL3: ; cpy_r_r196 = PyTuple_New(2); if (unlikely(cpy_r_r196 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp350 = cpy_r_r195.f0; - PyTuple_SET_ITEM(cpy_r_r196, 0, __tmp350); - PyObject *__tmp351 = cpy_r_r195.f1; - PyTuple_SET_ITEM(cpy_r_r196, 1, __tmp351); + PyObject *__tmp357 = cpy_r_r195.f0; + PyTuple_SET_ITEM(cpy_r_r196, 0, __tmp357); + PyObject *__tmp358 = cpy_r_r195.f1; + PyTuple_SET_ITEM(cpy_r_r196, 1, __tmp358); cpy_r_r197 = PyObject_GetItem(cpy_r_r190, cpy_r_r196); CPy_DECREF(cpy_r_r190); CPy_DECREF(cpy_r_r196); @@ -114984,14 +117978,14 @@ CPyL3: ; cpy_r_r205 = PyTuple_New(4); if (unlikely(cpy_r_r205 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp352 = cpy_r_r204.f0; - PyTuple_SET_ITEM(cpy_r_r205, 0, __tmp352); - PyObject *__tmp353 = cpy_r_r204.f1; - PyTuple_SET_ITEM(cpy_r_r205, 1, __tmp353); - PyObject *__tmp354 = cpy_r_r204.f2; - PyTuple_SET_ITEM(cpy_r_r205, 2, __tmp354); - PyObject *__tmp355 = cpy_r_r204.f3; - PyTuple_SET_ITEM(cpy_r_r205, 3, __tmp355); + PyObject *__tmp359 = cpy_r_r204.f0; + PyTuple_SET_ITEM(cpy_r_r205, 0, __tmp359); + PyObject *__tmp360 = cpy_r_r204.f1; + PyTuple_SET_ITEM(cpy_r_r205, 1, __tmp360); + PyObject *__tmp361 = cpy_r_r204.f2; + PyTuple_SET_ITEM(cpy_r_r205, 2, __tmp361); + PyObject *__tmp362 = cpy_r_r204.f3; + PyTuple_SET_ITEM(cpy_r_r205, 3, __tmp362); cpy_r_r206 = PyObject_GetItem(cpy_r_r180, cpy_r_r205); CPy_DECREF(cpy_r_r180); CPy_DECREF(cpy_r_r205); @@ -115225,10 +118219,10 @@ CPyL3: ; cpy_r_r309 = PyTuple_New(2); if (unlikely(cpy_r_r309 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp356 = cpy_r_r308.f0; - PyTuple_SET_ITEM(cpy_r_r309, 0, __tmp356); - PyObject *__tmp357 = cpy_r_r308.f1; - PyTuple_SET_ITEM(cpy_r_r309, 1, __tmp357); + PyObject *__tmp363 = cpy_r_r308.f0; + PyTuple_SET_ITEM(cpy_r_r309, 0, __tmp363); + PyObject *__tmp364 = cpy_r_r308.f1; + PyTuple_SET_ITEM(cpy_r_r309, 1, __tmp364); cpy_r_r310 = PyObject_GetItem(cpy_r_r303, cpy_r_r309); CPy_DECREF(cpy_r_r303); CPy_DECREF(cpy_r_r309); @@ -115241,10 +118235,10 @@ CPyL3: ; cpy_r_r312 = PyTuple_New(2); if (unlikely(cpy_r_r312 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp358 = cpy_r_r311.f0; - PyTuple_SET_ITEM(cpy_r_r312, 0, __tmp358); - PyObject *__tmp359 = cpy_r_r311.f1; - PyTuple_SET_ITEM(cpy_r_r312, 1, __tmp359); + PyObject *__tmp365 = cpy_r_r311.f0; + PyTuple_SET_ITEM(cpy_r_r312, 0, __tmp365); + PyObject *__tmp366 = cpy_r_r311.f1; + PyTuple_SET_ITEM(cpy_r_r312, 1, __tmp366); cpy_r_r313 = PyObject_GetItem(cpy_r_r297, cpy_r_r312); CPy_DECREF(cpy_r_r297); CPy_DECREF(cpy_r_r312); @@ -116180,10 +119174,10 @@ CPyL205: ; cpy_r_r674 = PyTuple_New(2); if (unlikely(cpy_r_r674 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp360 = cpy_r_r673.f0; - PyTuple_SET_ITEM(cpy_r_r674, 0, __tmp360); - PyObject *__tmp361 = cpy_r_r673.f1; - PyTuple_SET_ITEM(cpy_r_r674, 1, __tmp361); + PyObject *__tmp367 = cpy_r_r673.f0; + PyTuple_SET_ITEM(cpy_r_r674, 0, __tmp367); + PyObject *__tmp368 = cpy_r_r673.f1; + PyTuple_SET_ITEM(cpy_r_r674, 1, __tmp368); cpy_r_r675 = PyObject_GetItem(cpy_r_r668, cpy_r_r674); CPy_DECREF(cpy_r_r668); CPy_DECREF(cpy_r_r674); @@ -116305,10 +119299,10 @@ CPyL205: ; cpy_r_r733 = PyTuple_New(2); if (unlikely(cpy_r_r733 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp362 = cpy_r_r732.f0; - PyTuple_SET_ITEM(cpy_r_r733, 0, __tmp362); - PyObject *__tmp363 = cpy_r_r732.f1; - PyTuple_SET_ITEM(cpy_r_r733, 1, __tmp363); + PyObject *__tmp369 = cpy_r_r732.f0; + PyTuple_SET_ITEM(cpy_r_r733, 0, __tmp369); + PyObject *__tmp370 = cpy_r_r732.f1; + PyTuple_SET_ITEM(cpy_r_r733, 1, __tmp370); cpy_r_r734 = PyObject_GetItem(cpy_r_r727, cpy_r_r733); CPy_DECREF(cpy_r_r727); CPy_DECREF(cpy_r_r733); @@ -116625,10 +119619,10 @@ CPyL268: ; cpy_r_r854 = PyTuple_New(2); if (unlikely(cpy_r_r854 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp364 = cpy_r_r853.f0; - PyTuple_SET_ITEM(cpy_r_r854, 0, __tmp364); - PyObject *__tmp365 = cpy_r_r853.f1; - PyTuple_SET_ITEM(cpy_r_r854, 1, __tmp365); + PyObject *__tmp371 = cpy_r_r853.f0; + PyTuple_SET_ITEM(cpy_r_r854, 0, __tmp371); + PyObject *__tmp372 = cpy_r_r853.f1; + PyTuple_SET_ITEM(cpy_r_r854, 1, __tmp372); cpy_r_r855 = PyObject_GetItem(cpy_r_r846, cpy_r_r854); CPy_DECREF(cpy_r_r846); CPy_DECREF(cpy_r_r854); @@ -116683,14 +119677,14 @@ CPyL268: ; cpy_r_r873 = PyTuple_New(4); if (unlikely(cpy_r_r873 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp366 = cpy_r_r872.f0; - PyTuple_SET_ITEM(cpy_r_r873, 0, __tmp366); - PyObject *__tmp367 = cpy_r_r872.f1; - PyTuple_SET_ITEM(cpy_r_r873, 1, __tmp367); - PyObject *__tmp368 = cpy_r_r872.f2; - PyTuple_SET_ITEM(cpy_r_r873, 2, __tmp368); - PyObject *__tmp369 = cpy_r_r872.f3; - PyTuple_SET_ITEM(cpy_r_r873, 3, __tmp369); + PyObject *__tmp373 = cpy_r_r872.f0; + PyTuple_SET_ITEM(cpy_r_r873, 0, __tmp373); + PyObject *__tmp374 = cpy_r_r872.f1; + PyTuple_SET_ITEM(cpy_r_r873, 1, __tmp374); + PyObject *__tmp375 = cpy_r_r872.f2; + PyTuple_SET_ITEM(cpy_r_r873, 2, __tmp375); + PyObject *__tmp376 = cpy_r_r872.f3; + PyTuple_SET_ITEM(cpy_r_r873, 3, __tmp376); cpy_r_r874 = PyObject_GetItem(cpy_r_r863, cpy_r_r873); CPy_DECREF(cpy_r_r863); CPy_DECREF(cpy_r_r873); @@ -116729,10 +119723,10 @@ CPyL268: ; cpy_r_r887 = PyTuple_New(2); if (unlikely(cpy_r_r887 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp370 = cpy_r_r886.f0; - PyTuple_SET_ITEM(cpy_r_r887, 0, __tmp370); - PyObject *__tmp371 = cpy_r_r886.f1; - PyTuple_SET_ITEM(cpy_r_r887, 1, __tmp371); + PyObject *__tmp377 = cpy_r_r886.f0; + PyTuple_SET_ITEM(cpy_r_r887, 0, __tmp377); + PyObject *__tmp378 = cpy_r_r886.f1; + PyTuple_SET_ITEM(cpy_r_r887, 1, __tmp378); cpy_r_r888 = PyObject_GetItem(cpy_r_r881, cpy_r_r887); CPy_DECREF(cpy_r_r881); CPy_DECREF(cpy_r_r887); @@ -116770,12 +119764,12 @@ CPyL268: ; cpy_r_r901 = PyTuple_New(3); if (unlikely(cpy_r_r901 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp372 = cpy_r_r900.f0; - PyTuple_SET_ITEM(cpy_r_r901, 0, __tmp372); - PyObject *__tmp373 = cpy_r_r900.f1; - PyTuple_SET_ITEM(cpy_r_r901, 1, __tmp373); - PyObject *__tmp374 = cpy_r_r900.f2; - PyTuple_SET_ITEM(cpy_r_r901, 2, __tmp374); + PyObject *__tmp379 = cpy_r_r900.f0; + PyTuple_SET_ITEM(cpy_r_r901, 0, __tmp379); + PyObject *__tmp380 = cpy_r_r900.f1; + PyTuple_SET_ITEM(cpy_r_r901, 1, __tmp380); + PyObject *__tmp381 = cpy_r_r900.f2; + PyTuple_SET_ITEM(cpy_r_r901, 2, __tmp381); cpy_r_r902 = PyObject_GetItem(cpy_r_r892, cpy_r_r901); CPy_DECREF(cpy_r_r892); CPy_DECREF(cpy_r_r901); @@ -116815,10 +119809,10 @@ CPyL268: ; cpy_r_r918 = PyTuple_New(2); if (unlikely(cpy_r_r918 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp375 = cpy_r_r917.f0; - PyTuple_SET_ITEM(cpy_r_r918, 0, __tmp375); - PyObject *__tmp376 = cpy_r_r917.f1; - PyTuple_SET_ITEM(cpy_r_r918, 1, __tmp376); + PyObject *__tmp382 = cpy_r_r917.f0; + PyTuple_SET_ITEM(cpy_r_r918, 0, __tmp382); + PyObject *__tmp383 = cpy_r_r917.f1; + PyTuple_SET_ITEM(cpy_r_r918, 1, __tmp383); cpy_r_r919 = PyObject_GetItem(cpy_r_r912, cpy_r_r918); CPy_DECREF(cpy_r_r912); CPy_DECREF(cpy_r_r918); @@ -116848,10 +119842,10 @@ CPyL268: ; cpy_r_r929 = PyTuple_New(2); if (unlikely(cpy_r_r929 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp377 = cpy_r_r928.f0; - PyTuple_SET_ITEM(cpy_r_r929, 0, __tmp377); - PyObject *__tmp378 = cpy_r_r928.f1; - PyTuple_SET_ITEM(cpy_r_r929, 1, __tmp378); + PyObject *__tmp384 = cpy_r_r928.f0; + PyTuple_SET_ITEM(cpy_r_r929, 0, __tmp384); + PyObject *__tmp385 = cpy_r_r928.f1; + PyTuple_SET_ITEM(cpy_r_r929, 1, __tmp385); cpy_r_r930 = PyObject_GetItem(cpy_r_r923, cpy_r_r929); CPy_DECREF(cpy_r_r923); CPy_DECREF(cpy_r_r929); @@ -116881,10 +119875,10 @@ CPyL268: ; cpy_r_r940 = PyTuple_New(2); if (unlikely(cpy_r_r940 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp379 = cpy_r_r939.f0; - PyTuple_SET_ITEM(cpy_r_r940, 0, __tmp379); - PyObject *__tmp380 = cpy_r_r939.f1; - PyTuple_SET_ITEM(cpy_r_r940, 1, __tmp380); + PyObject *__tmp386 = cpy_r_r939.f0; + PyTuple_SET_ITEM(cpy_r_r940, 0, __tmp386); + PyObject *__tmp387 = cpy_r_r939.f1; + PyTuple_SET_ITEM(cpy_r_r940, 1, __tmp387); cpy_r_r941 = PyObject_GetItem(cpy_r_r934, cpy_r_r940); CPy_DECREF(cpy_r_r934); CPy_DECREF(cpy_r_r940); @@ -116930,12 +119924,12 @@ CPyL268: ; cpy_r_r958 = PyTuple_New(3); if (unlikely(cpy_r_r958 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp381 = cpy_r_r957.f0; - PyTuple_SET_ITEM(cpy_r_r958, 0, __tmp381); - PyObject *__tmp382 = cpy_r_r957.f1; - PyTuple_SET_ITEM(cpy_r_r958, 1, __tmp382); - PyObject *__tmp383 = cpy_r_r957.f2; - PyTuple_SET_ITEM(cpy_r_r958, 2, __tmp383); + PyObject *__tmp388 = cpy_r_r957.f0; + PyTuple_SET_ITEM(cpy_r_r958, 0, __tmp388); + PyObject *__tmp389 = cpy_r_r957.f1; + PyTuple_SET_ITEM(cpy_r_r958, 1, __tmp389); + PyObject *__tmp390 = cpy_r_r957.f2; + PyTuple_SET_ITEM(cpy_r_r958, 2, __tmp390); cpy_r_r959 = PyObject_GetItem(cpy_r_r949, cpy_r_r958); CPy_DECREF(cpy_r_r949); CPy_DECREF(cpy_r_r958); @@ -116965,10 +119959,10 @@ CPyL268: ; cpy_r_r969 = PyTuple_New(2); if (unlikely(cpy_r_r969 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp384 = cpy_r_r968.f0; - PyTuple_SET_ITEM(cpy_r_r969, 0, __tmp384); - PyObject *__tmp385 = cpy_r_r968.f1; - PyTuple_SET_ITEM(cpy_r_r969, 1, __tmp385); + PyObject *__tmp391 = cpy_r_r968.f0; + PyTuple_SET_ITEM(cpy_r_r969, 0, __tmp391); + PyObject *__tmp392 = cpy_r_r968.f1; + PyTuple_SET_ITEM(cpy_r_r969, 1, __tmp392); cpy_r_r970 = PyObject_GetItem(cpy_r_r963, cpy_r_r969); CPy_DECREF(cpy_r_r963); CPy_DECREF(cpy_r_r969); @@ -119396,16 +122390,16 @@ CPyL674: ; cpy_r_r1897 = PyTuple_New(5); if (unlikely(cpy_r_r1897 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp386 = cpy_r_r1896.f0; - PyTuple_SET_ITEM(cpy_r_r1897, 0, __tmp386); - PyObject *__tmp387 = cpy_r_r1896.f1; - PyTuple_SET_ITEM(cpy_r_r1897, 1, __tmp387); - PyObject *__tmp388 = cpy_r_r1896.f2; - PyTuple_SET_ITEM(cpy_r_r1897, 2, __tmp388); - PyObject *__tmp389 = cpy_r_r1896.f3; - PyTuple_SET_ITEM(cpy_r_r1897, 3, __tmp389); - PyObject *__tmp390 = cpy_r_r1896.f4; - PyTuple_SET_ITEM(cpy_r_r1897, 4, __tmp390); + PyObject *__tmp393 = cpy_r_r1896.f0; + PyTuple_SET_ITEM(cpy_r_r1897, 0, __tmp393); + PyObject *__tmp394 = cpy_r_r1896.f1; + PyTuple_SET_ITEM(cpy_r_r1897, 1, __tmp394); + PyObject *__tmp395 = cpy_r_r1896.f2; + PyTuple_SET_ITEM(cpy_r_r1897, 2, __tmp395); + PyObject *__tmp396 = cpy_r_r1896.f3; + PyTuple_SET_ITEM(cpy_r_r1897, 3, __tmp396); + PyObject *__tmp397 = cpy_r_r1896.f4; + PyTuple_SET_ITEM(cpy_r_r1897, 4, __tmp397); cpy_r_r1898 = PyObject_GetItem(cpy_r_r1880, cpy_r_r1897); CPy_DECREF(cpy_r_r1880); CPy_DECREF(cpy_r_r1897); @@ -119445,10 +122439,10 @@ CPyL674: ; cpy_r_r1912 = PyTuple_New(2); if (unlikely(cpy_r_r1912 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp391 = cpy_r_r1911.f0; - PyTuple_SET_ITEM(cpy_r_r1912, 0, __tmp391); - PyObject *__tmp392 = cpy_r_r1911.f1; - PyTuple_SET_ITEM(cpy_r_r1912, 1, __tmp392); + PyObject *__tmp398 = cpy_r_r1911.f0; + PyTuple_SET_ITEM(cpy_r_r1912, 0, __tmp398); + PyObject *__tmp399 = cpy_r_r1911.f1; + PyTuple_SET_ITEM(cpy_r_r1912, 1, __tmp399); cpy_r_r1913 = PyObject_GetItem(cpy_r_r1908, cpy_r_r1912); CPy_DECREF(cpy_r_r1908); CPy_DECREF(cpy_r_r1912); @@ -119913,18 +122907,18 @@ CPyL741: ; cpy_r_r2089 = PyTuple_New(6); if (unlikely(cpy_r_r2089 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp393 = cpy_r_r2088.f0; - PyTuple_SET_ITEM(cpy_r_r2089, 0, __tmp393); - PyObject *__tmp394 = cpy_r_r2088.f1; - PyTuple_SET_ITEM(cpy_r_r2089, 1, __tmp394); - PyObject *__tmp395 = cpy_r_r2088.f2; - PyTuple_SET_ITEM(cpy_r_r2089, 2, __tmp395); - PyObject *__tmp396 = cpy_r_r2088.f3; - PyTuple_SET_ITEM(cpy_r_r2089, 3, __tmp396); - PyObject *__tmp397 = cpy_r_r2088.f4; - PyTuple_SET_ITEM(cpy_r_r2089, 4, __tmp397); - PyObject *__tmp398 = cpy_r_r2088.f5; - PyTuple_SET_ITEM(cpy_r_r2089, 5, __tmp398); + PyObject *__tmp400 = cpy_r_r2088.f0; + PyTuple_SET_ITEM(cpy_r_r2089, 0, __tmp400); + PyObject *__tmp401 = cpy_r_r2088.f1; + PyTuple_SET_ITEM(cpy_r_r2089, 1, __tmp401); + PyObject *__tmp402 = cpy_r_r2088.f2; + PyTuple_SET_ITEM(cpy_r_r2089, 2, __tmp402); + PyObject *__tmp403 = cpy_r_r2088.f3; + PyTuple_SET_ITEM(cpy_r_r2089, 3, __tmp403); + PyObject *__tmp404 = cpy_r_r2088.f4; + PyTuple_SET_ITEM(cpy_r_r2089, 4, __tmp404); + PyObject *__tmp405 = cpy_r_r2088.f5; + PyTuple_SET_ITEM(cpy_r_r2089, 5, __tmp405); cpy_r_r2090 = PyObject_GetItem(cpy_r_r2069, cpy_r_r2089); CPy_DECREF(cpy_r_r2069); CPy_DECREF(cpy_r_r2089); @@ -120326,10 +123320,10 @@ CPyL807: ; cpy_r_r2238 = PyTuple_New(2); if (unlikely(cpy_r_r2238 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp399 = cpy_r_r2237.f0; - PyTuple_SET_ITEM(cpy_r_r2238, 0, __tmp399); - PyObject *__tmp400 = cpy_r_r2237.f1; - PyTuple_SET_ITEM(cpy_r_r2238, 1, __tmp400); + PyObject *__tmp406 = cpy_r_r2237.f0; + PyTuple_SET_ITEM(cpy_r_r2238, 0, __tmp406); + PyObject *__tmp407 = cpy_r_r2237.f1; + PyTuple_SET_ITEM(cpy_r_r2238, 1, __tmp407); cpy_r_r2239 = PyObject_GetItem(cpy_r_r2223, cpy_r_r2238); CPy_DECREF(cpy_r_r2223); CPy_DECREF(cpy_r_r2238); @@ -120386,10 +123380,10 @@ CPyL807: ; cpy_r_r2260 = PyTuple_New(2); if (unlikely(cpy_r_r2260 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp401 = cpy_r_r2259.f0; - PyTuple_SET_ITEM(cpy_r_r2260, 0, __tmp401); - PyObject *__tmp402 = cpy_r_r2259.f1; - PyTuple_SET_ITEM(cpy_r_r2260, 1, __tmp402); + PyObject *__tmp408 = cpy_r_r2259.f0; + PyTuple_SET_ITEM(cpy_r_r2260, 0, __tmp408); + PyObject *__tmp409 = cpy_r_r2259.f1; + PyTuple_SET_ITEM(cpy_r_r2260, 1, __tmp409); cpy_r_r2261 = PyObject_GetItem(cpy_r_r2252, cpy_r_r2260); CPy_DECREF(cpy_r_r2252); CPy_DECREF(cpy_r_r2260); @@ -120452,10 +123446,10 @@ CPyL807: ; cpy_r_r2280 = PyTuple_New(2); if (unlikely(cpy_r_r2280 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp403 = cpy_r_r2279.f0; - PyTuple_SET_ITEM(cpy_r_r2280, 0, __tmp403); - PyObject *__tmp404 = cpy_r_r2279.f1; - PyTuple_SET_ITEM(cpy_r_r2280, 1, __tmp404); + PyObject *__tmp410 = cpy_r_r2279.f0; + PyTuple_SET_ITEM(cpy_r_r2280, 0, __tmp410); + PyObject *__tmp411 = cpy_r_r2279.f1; + PyTuple_SET_ITEM(cpy_r_r2280, 1, __tmp411); cpy_r_r2281 = PyObject_GetItem(cpy_r_r2268, cpy_r_r2280); CPy_DECREF(cpy_r_r2268); CPy_DECREF(cpy_r_r2280); @@ -120468,10 +123462,10 @@ CPyL807: ; cpy_r_r2283 = PyTuple_New(2); if (unlikely(cpy_r_r2283 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp405 = cpy_r_r2282.f0; - PyTuple_SET_ITEM(cpy_r_r2283, 0, __tmp405); - PyObject *__tmp406 = cpy_r_r2282.f1; - PyTuple_SET_ITEM(cpy_r_r2283, 1, __tmp406); + PyObject *__tmp412 = cpy_r_r2282.f0; + PyTuple_SET_ITEM(cpy_r_r2283, 0, __tmp412); + PyObject *__tmp413 = cpy_r_r2282.f1; + PyTuple_SET_ITEM(cpy_r_r2283, 1, __tmp413); cpy_r_r2284 = PyObject_GetItem(cpy_r_r2246, cpy_r_r2283); CPy_DECREF(cpy_r_r2246); CPy_DECREF(cpy_r_r2283); @@ -120553,12 +123547,12 @@ CPyL807: ; cpy_r_r2315 = PyTuple_New(3); if (unlikely(cpy_r_r2315 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp407 = cpy_r_r2314.f0; - PyTuple_SET_ITEM(cpy_r_r2315, 0, __tmp407); - PyObject *__tmp408 = cpy_r_r2314.f1; - PyTuple_SET_ITEM(cpy_r_r2315, 1, __tmp408); - PyObject *__tmp409 = cpy_r_r2314.f2; - PyTuple_SET_ITEM(cpy_r_r2315, 2, __tmp409); + PyObject *__tmp414 = cpy_r_r2314.f0; + PyTuple_SET_ITEM(cpy_r_r2315, 0, __tmp414); + PyObject *__tmp415 = cpy_r_r2314.f1; + PyTuple_SET_ITEM(cpy_r_r2315, 1, __tmp415); + PyObject *__tmp416 = cpy_r_r2314.f2; + PyTuple_SET_ITEM(cpy_r_r2315, 2, __tmp416); cpy_r_r2316 = PyObject_GetItem(cpy_r_r2304, cpy_r_r2315); CPy_DECREF(cpy_r_r2304); CPy_DECREF(cpy_r_r2315); @@ -120571,10 +123565,10 @@ CPyL807: ; cpy_r_r2318 = PyTuple_New(2); if (unlikely(cpy_r_r2318 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp410 = cpy_r_r2317.f0; - PyTuple_SET_ITEM(cpy_r_r2318, 0, __tmp410); - PyObject *__tmp411 = cpy_r_r2317.f1; - PyTuple_SET_ITEM(cpy_r_r2318, 1, __tmp411); + PyObject *__tmp417 = cpy_r_r2317.f0; + PyTuple_SET_ITEM(cpy_r_r2318, 0, __tmp417); + PyObject *__tmp418 = cpy_r_r2317.f1; + PyTuple_SET_ITEM(cpy_r_r2318, 1, __tmp418); cpy_r_r2319 = PyObject_GetItem(cpy_r_r2291, cpy_r_r2318); CPy_DECREF(cpy_r_r2291); CPy_DECREF(cpy_r_r2318); @@ -120631,10 +123625,10 @@ CPyL807: ; cpy_r_r2340 = PyTuple_New(2); if (unlikely(cpy_r_r2340 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp412 = cpy_r_r2339.f0; - PyTuple_SET_ITEM(cpy_r_r2340, 0, __tmp412); - PyObject *__tmp413 = cpy_r_r2339.f1; - PyTuple_SET_ITEM(cpy_r_r2340, 1, __tmp413); + PyObject *__tmp419 = cpy_r_r2339.f0; + PyTuple_SET_ITEM(cpy_r_r2340, 0, __tmp419); + PyObject *__tmp420 = cpy_r_r2339.f1; + PyTuple_SET_ITEM(cpy_r_r2340, 1, __tmp420); cpy_r_r2341 = PyObject_GetItem(cpy_r_r2332, cpy_r_r2340); CPy_DECREF(cpy_r_r2332); CPy_DECREF(cpy_r_r2340); @@ -120718,10 +123712,10 @@ CPyL807: ; cpy_r_r2369 = PyTuple_New(2); if (unlikely(cpy_r_r2369 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp414 = cpy_r_r2368.f0; - PyTuple_SET_ITEM(cpy_r_r2369, 0, __tmp414); - PyObject *__tmp415 = cpy_r_r2368.f1; - PyTuple_SET_ITEM(cpy_r_r2369, 1, __tmp415); + PyObject *__tmp421 = cpy_r_r2368.f0; + PyTuple_SET_ITEM(cpy_r_r2369, 0, __tmp421); + PyObject *__tmp422 = cpy_r_r2368.f1; + PyTuple_SET_ITEM(cpy_r_r2369, 1, __tmp422); cpy_r_r2370 = PyObject_GetItem(cpy_r_r2357, cpy_r_r2369); CPy_DECREF(cpy_r_r2357); CPy_DECREF(cpy_r_r2369); @@ -120735,12 +123729,12 @@ CPyL807: ; cpy_r_r2372 = PyTuple_New(3); if (unlikely(cpy_r_r2372 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp416 = cpy_r_r2371.f0; - PyTuple_SET_ITEM(cpy_r_r2372, 0, __tmp416); - PyObject *__tmp417 = cpy_r_r2371.f1; - PyTuple_SET_ITEM(cpy_r_r2372, 1, __tmp417); - PyObject *__tmp418 = cpy_r_r2371.f2; - PyTuple_SET_ITEM(cpy_r_r2372, 2, __tmp418); + PyObject *__tmp423 = cpy_r_r2371.f0; + PyTuple_SET_ITEM(cpy_r_r2372, 0, __tmp423); + PyObject *__tmp424 = cpy_r_r2371.f1; + PyTuple_SET_ITEM(cpy_r_r2372, 1, __tmp424); + PyObject *__tmp425 = cpy_r_r2371.f2; + PyTuple_SET_ITEM(cpy_r_r2372, 2, __tmp425); cpy_r_r2373 = PyObject_GetItem(cpy_r_r2348, cpy_r_r2372); CPy_DECREF(cpy_r_r2348); CPy_DECREF(cpy_r_r2372); @@ -120753,10 +123747,10 @@ CPyL807: ; cpy_r_r2375 = PyTuple_New(2); if (unlikely(cpy_r_r2375 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp419 = cpy_r_r2374.f0; - PyTuple_SET_ITEM(cpy_r_r2375, 0, __tmp419); - PyObject *__tmp420 = cpy_r_r2374.f1; - PyTuple_SET_ITEM(cpy_r_r2375, 1, __tmp420); + PyObject *__tmp426 = cpy_r_r2374.f0; + PyTuple_SET_ITEM(cpy_r_r2375, 0, __tmp426); + PyObject *__tmp427 = cpy_r_r2374.f1; + PyTuple_SET_ITEM(cpy_r_r2375, 1, __tmp427); cpy_r_r2376 = PyObject_GetItem(cpy_r_r2326, cpy_r_r2375); CPy_DECREF(cpy_r_r2326); CPy_DECREF(cpy_r_r2375); @@ -121544,12 +124538,12 @@ CPyL973: ; cpy_r_r2677 = PyTuple_New(3); if (unlikely(cpy_r_r2677 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp421 = cpy_r_r2676.f0; - PyTuple_SET_ITEM(cpy_r_r2677, 0, __tmp421); - PyObject *__tmp422 = cpy_r_r2676.f1; - PyTuple_SET_ITEM(cpy_r_r2677, 1, __tmp422); - PyObject *__tmp423 = cpy_r_r2676.f2; - PyTuple_SET_ITEM(cpy_r_r2677, 2, __tmp423); + PyObject *__tmp428 = cpy_r_r2676.f0; + PyTuple_SET_ITEM(cpy_r_r2677, 0, __tmp428); + PyObject *__tmp429 = cpy_r_r2676.f1; + PyTuple_SET_ITEM(cpy_r_r2677, 1, __tmp429); + PyObject *__tmp430 = cpy_r_r2676.f2; + PyTuple_SET_ITEM(cpy_r_r2677, 2, __tmp430); cpy_r_r2678 = PyObject_GetItem(cpy_r_r2668, cpy_r_r2677); CPy_DECREF(cpy_r_r2668); CPy_DECREF(cpy_r_r2677); @@ -121569,10 +124563,10 @@ CPyL973: ; cpy_r_r2683 = PyTuple_New(2); if (unlikely(cpy_r_r2683 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp424 = cpy_r_r2682.f0; - PyTuple_SET_ITEM(cpy_r_r2683, 0, __tmp424); - PyObject *__tmp425 = cpy_r_r2682.f1; - PyTuple_SET_ITEM(cpy_r_r2683, 1, __tmp425); + PyObject *__tmp431 = cpy_r_r2682.f0; + PyTuple_SET_ITEM(cpy_r_r2683, 0, __tmp431); + PyObject *__tmp432 = cpy_r_r2682.f1; + PyTuple_SET_ITEM(cpy_r_r2683, 1, __tmp432); cpy_r_r2684 = PyObject_GetItem(cpy_r_r2665, cpy_r_r2683); CPy_DECREF(cpy_r_r2665); CPy_DECREF(cpy_r_r2683); @@ -121634,10 +124628,10 @@ CPyL973: ; cpy_r_r2707 = PyTuple_New(2); if (unlikely(cpy_r_r2707 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp426 = cpy_r_r2706.f0; - PyTuple_SET_ITEM(cpy_r_r2707, 0, __tmp426); - PyObject *__tmp427 = cpy_r_r2706.f1; - PyTuple_SET_ITEM(cpy_r_r2707, 1, __tmp427); + PyObject *__tmp433 = cpy_r_r2706.f0; + PyTuple_SET_ITEM(cpy_r_r2707, 0, __tmp433); + PyObject *__tmp434 = cpy_r_r2706.f1; + PyTuple_SET_ITEM(cpy_r_r2707, 1, __tmp434); cpy_r_r2708 = PyObject_GetItem(cpy_r_r2694, cpy_r_r2707); CPy_DECREF(cpy_r_r2694); CPy_DECREF(cpy_r_r2707); @@ -121683,10 +124677,10 @@ CPyL973: ; cpy_r_r2724 = PyTuple_New(2); if (unlikely(cpy_r_r2724 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp428 = cpy_r_r2723.f0; - PyTuple_SET_ITEM(cpy_r_r2724, 0, __tmp428); - PyObject *__tmp429 = cpy_r_r2723.f1; - PyTuple_SET_ITEM(cpy_r_r2724, 1, __tmp429); + PyObject *__tmp435 = cpy_r_r2723.f0; + PyTuple_SET_ITEM(cpy_r_r2724, 0, __tmp435); + PyObject *__tmp436 = cpy_r_r2723.f1; + PyTuple_SET_ITEM(cpy_r_r2724, 1, __tmp436); cpy_r_r2725 = PyObject_GetItem(cpy_r_r2711, cpy_r_r2724); CPy_DECREF(cpy_r_r2711); CPy_DECREF(cpy_r_r2724); @@ -121699,10 +124693,10 @@ CPyL973: ; cpy_r_r2727 = PyTuple_New(2); if (unlikely(cpy_r_r2727 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp430 = cpy_r_r2726.f0; - PyTuple_SET_ITEM(cpy_r_r2727, 0, __tmp430); - PyObject *__tmp431 = cpy_r_r2726.f1; - PyTuple_SET_ITEM(cpy_r_r2727, 1, __tmp431); + PyObject *__tmp437 = cpy_r_r2726.f0; + PyTuple_SET_ITEM(cpy_r_r2727, 0, __tmp437); + PyObject *__tmp438 = cpy_r_r2726.f1; + PyTuple_SET_ITEM(cpy_r_r2727, 1, __tmp438); cpy_r_r2728 = PyObject_GetItem(cpy_r_r2691, cpy_r_r2727); CPy_DECREF(cpy_r_r2691); CPy_DECREF(cpy_r_r2727); @@ -125223,10 +128217,10 @@ CPyL1512: ; cpy_r_r4103 = PyTuple_New(2); if (unlikely(cpy_r_r4103 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp432 = cpy_r_r4102.f0; - PyTuple_SET_ITEM(cpy_r_r4103, 0, __tmp432); - PyObject *__tmp433 = cpy_r_r4102.f1; - PyTuple_SET_ITEM(cpy_r_r4103, 1, __tmp433); + PyObject *__tmp439 = cpy_r_r4102.f0; + PyTuple_SET_ITEM(cpy_r_r4103, 0, __tmp439); + PyObject *__tmp440 = cpy_r_r4102.f1; + PyTuple_SET_ITEM(cpy_r_r4103, 1, __tmp440); cpy_r_r4104 = PyObject_GetItem(cpy_r_r4095, cpy_r_r4103); CPy_DECREF(cpy_r_r4095); CPy_DECREF(cpy_r_r4103); @@ -125259,10 +128253,10 @@ CPyL1512: ; cpy_r_r4115 = PyTuple_New(2); if (unlikely(cpy_r_r4115 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp434 = cpy_r_r4114.f0; - PyTuple_SET_ITEM(cpy_r_r4115, 0, __tmp434); - PyObject *__tmp435 = cpy_r_r4114.f1; - PyTuple_SET_ITEM(cpy_r_r4115, 1, __tmp435); + PyObject *__tmp441 = cpy_r_r4114.f0; + PyTuple_SET_ITEM(cpy_r_r4115, 0, __tmp441); + PyObject *__tmp442 = cpy_r_r4114.f1; + PyTuple_SET_ITEM(cpy_r_r4115, 1, __tmp442); cpy_r_r4116 = PyObject_GetItem(cpy_r_r4111, cpy_r_r4115); CPy_DECREF(cpy_r_r4111); CPy_DECREF(cpy_r_r4115); @@ -126626,10 +129620,10 @@ CPyL1716: ; cpy_r_r4637 = PyTuple_New(2); if (unlikely(cpy_r_r4637 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp436 = cpy_r_r4636.f0; - PyTuple_SET_ITEM(cpy_r_r4637, 0, __tmp436); - PyObject *__tmp437 = cpy_r_r4636.f1; - PyTuple_SET_ITEM(cpy_r_r4637, 1, __tmp437); + PyObject *__tmp443 = cpy_r_r4636.f0; + PyTuple_SET_ITEM(cpy_r_r4637, 0, __tmp443); + PyObject *__tmp444 = cpy_r_r4636.f1; + PyTuple_SET_ITEM(cpy_r_r4637, 1, __tmp444); cpy_r_r4638 = PyObject_GetItem(cpy_r_r4631, cpy_r_r4637); CPy_DECREF(cpy_r_r4631); CPy_DECREF(cpy_r_r4637); @@ -126684,10 +129678,10 @@ CPyL1716: ; cpy_r_r4658 = PyTuple_New(2); if (unlikely(cpy_r_r4658 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp438 = cpy_r_r4657.f0; - PyTuple_SET_ITEM(cpy_r_r4658, 0, __tmp438); - PyObject *__tmp439 = cpy_r_r4657.f1; - PyTuple_SET_ITEM(cpy_r_r4658, 1, __tmp439); + PyObject *__tmp445 = cpy_r_r4657.f0; + PyTuple_SET_ITEM(cpy_r_r4658, 0, __tmp445); + PyObject *__tmp446 = cpy_r_r4657.f1; + PyTuple_SET_ITEM(cpy_r_r4658, 1, __tmp446); cpy_r_r4659 = PyObject_GetItem(cpy_r_r4652, cpy_r_r4658); CPy_DECREF(cpy_r_r4652); CPy_DECREF(cpy_r_r4658); @@ -126746,12 +129740,12 @@ CPyL1716: ; cpy_r_r4680 = PyTuple_New(3); if (unlikely(cpy_r_r4680 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp440 = cpy_r_r4679.f0; - PyTuple_SET_ITEM(cpy_r_r4680, 0, __tmp440); - PyObject *__tmp441 = cpy_r_r4679.f1; - PyTuple_SET_ITEM(cpy_r_r4680, 1, __tmp441); - PyObject *__tmp442 = cpy_r_r4679.f2; - PyTuple_SET_ITEM(cpy_r_r4680, 2, __tmp442); + PyObject *__tmp447 = cpy_r_r4679.f0; + PyTuple_SET_ITEM(cpy_r_r4680, 0, __tmp447); + PyObject *__tmp448 = cpy_r_r4679.f1; + PyTuple_SET_ITEM(cpy_r_r4680, 1, __tmp448); + PyObject *__tmp449 = cpy_r_r4679.f2; + PyTuple_SET_ITEM(cpy_r_r4680, 2, __tmp449); cpy_r_r4681 = PyObject_GetItem(cpy_r_r4675, cpy_r_r4680); CPy_DECREF(cpy_r_r4675); CPy_DECREF(cpy_r_r4680); @@ -127007,14 +130001,14 @@ CPyL1767: ; cpy_r_r4776 = PyTuple_New(4); if (unlikely(cpy_r_r4776 == NULL)) CPyError_OutOfMemory(); - PyObject *__tmp443 = cpy_r_r4775.f0; - PyTuple_SET_ITEM(cpy_r_r4776, 0, __tmp443); - PyObject *__tmp444 = cpy_r_r4775.f1; - PyTuple_SET_ITEM(cpy_r_r4776, 1, __tmp444); - PyObject *__tmp445 = cpy_r_r4775.f2; - PyTuple_SET_ITEM(cpy_r_r4776, 2, __tmp445); - PyObject *__tmp446 = cpy_r_r4775.f3; - PyTuple_SET_ITEM(cpy_r_r4776, 3, __tmp446); + PyObject *__tmp450 = cpy_r_r4775.f0; + PyTuple_SET_ITEM(cpy_r_r4776, 0, __tmp450); + PyObject *__tmp451 = cpy_r_r4775.f1; + PyTuple_SET_ITEM(cpy_r_r4776, 1, __tmp451); + PyObject *__tmp452 = cpy_r_r4775.f2; + PyTuple_SET_ITEM(cpy_r_r4776, 2, __tmp452); + PyObject *__tmp453 = cpy_r_r4775.f3; + PyTuple_SET_ITEM(cpy_r_r4776, 3, __tmp453); cpy_r_r4777 = PyObject_GetItem(cpy_r_r4770, cpy_r_r4776); CPy_DECREF(cpy_r_r4770); CPy_DECREF(cpy_r_r4776); @@ -129396,6 +132390,7 @@ int CPyGlobalsInit(void) CPyModule_faster_ens___utils = Py_None; CPyModule_builtins = Py_None; CPyModule_datetime = Py_None; + CPyModule_functools = Py_None; CPyModule_typing = Py_None; CPyModule_warnings = Py_None; CPyModule_eth_typing = Py_None; @@ -129614,13 +132609,20 @@ const char * const CPyLit_Str[] = { "\003\031 too long after encoding.\022ENSValidationError\bto_bytes", "\001q``ens_encode_name`` is deprecated and will be removed in the next major version. Use ``dns_encode_name`` instead.", "\006\022DeprecationWarning\004warn\nstacklevel\bdatetime\btimezone\003utc", - "\005\rfromtimestamp\006keccak\037Cannot generate hash for label \a{!r:{}}\006format", - "\004\v with a \'.\'\rENSValueError\017is_same_address\025to_normalized_address", - "\003\020remove_0x_prefix\r.addr.reverse$You must specify the sending account", - "\a\016AssertionError\apopitem\004from\fENSTypeError\003all\tAsyncWeb3\rAsyncWeb3Main", - "\006\bAsyncEth\fAsyncEthMain\nmiddleware\nCollection\bSequence\bwarnings", + "\005\rfromtimestamp\006keccak\016dispatch_cache\n_find_impl\tsha3_text", + "\004\037Cannot generate hash for label \a{!r:{}}\006format\v with a \'.\'", + "\004\rENSValueError\017is_same_address\025to_normalized_address\020remove_0x_prefix", + "\003\r.addr.reverse$You must specify the sending account\016AssertionError", + "\006\apopitem\004from\fENSTypeError\027is_none_or_zero_address\ris_empty_name\003all", + "\005\tAsyncWeb3\rAsyncWeb3Main\bAsyncEth\fAsyncEthMain\nmiddleware", + "\005\016singledispatch\tfunctools\nCollection\bSequence\bwarnings", "\004\023faster_ens/utils.py\aAddress\020faster_eth_utils\024faster_ens.constants", - "\005\006object\adefault\vAsyncBeacon\037faster_web3.beacon.async_beacon\006Beacon", + "\003\006object\adefault0__mypyc_singledispatch_main_function_sha3_text__", + "\002\bregistry\005clear", + "\001>__mypyc_singledispatch_main_function_is_none_or_zero_address__", + "\002\034is_none_or_zero_address_none\bregister", + "\0014__mypyc_singledispatch_main_function_is_empty_name__", + "\004\022is_empty_name_none\vAsyncBeacon\037faster_web3.beacon.async_beacon\006Beacon", "\004\031faster_web3.beacon.beacon\a__all__\026/eth/v1/beacon/genesis\vGET_GENESIS", "\002\036/eth/v1/beacon/states/{0}/root\rGET_HASH_ROOT", "\002\036/eth/v1/beacon/states/{0}/fork\rGET_FORK_DATA", @@ -129816,46 +132818,47 @@ const char * const CPyLit_Bytes[] = { "", }; const char * const CPyLit_Int[] = { - "\0250\00095\00065039\00048\00025000\00039000\000172800\0002\00016\0003600\000-1\000604800\000180\0001800\000300\000120\00060\0001\000600\00086400\000720", + "\0250\00095\00065039\00048\00025000\00039000\000172800\0002\0001\00016\0003600\000-1\000604800\000180\0001800\000300\000120\00060\000600\00086400\000720", "\0011000000000000000000", "", }; const double CPyLit_Float[] = {0}; const double CPyLit_Complex[] = {0}; const int CPyLit_Tuple[] = { - 138, 3, 54, 54, 54, 3, 55, 55, 55, 2, 963, 964, 1, 58, 1, 60, 12, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 3, 75, 75, 75, 1, 969, + 139, 3, 54, 54, 54, 3, 55, 55, 55, 2, 978, 979, 1, 58, 1, 60, 12, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 3, 75, 75, 75, 1, 984, 1, 18, 1, 65, 1, 134, 1, 151, 5, 153, 62, 69, 154, 72, 1, 155, 1, 148, 1, 158, 1, 160, 5, 162, 141, 163, 164, 165, 3, 155, 173, 174, 1, 201, 1, 202, 1, 204, 1, 205, 2, 169, 79, 1, 208, 1, 30, 1, 216, 1, 104, 1, - 224, 1, 245, 1, 246, 1, 247, 1, 248, 3, 249, 169, 79, 2, 225, 226, 8, - 153, 62, 250, 69, 251, 71, 154, 72, 3, 252, 252, 252, 1, 999, 4, 254, - 155, 173, 174, 4, 235, 237, 220, 236, 2, 243, 234, 6, 175, 176, 177, - 180, 178, 182, 2, 219, 18, 1, 259, 1, 261, 2, 353, 354, 2, 54, 354, 7, - 62, 64, 65, 67, 69, 72, 73, 1, 351, 2, 364, 174, 1, 350, 43, 309, 349, - 343, 311, 327, 325, 295, 299, 289, 293, 287, 285, 345, 291, 317, 323, - 279, 283, 281, 271, 269, 319, 265, 267, 337, 301, 305, 307, 303, 329, - 333, 335, 331, 313, 297, 321, 347, 341, 275, 277, 273, 339, 315, 2, - 375, 376, 6, 378, 379, 380, 381, 382, 383, 3, 410, 410, 410, 3, 411, - 411, 411, 3, 412, 412, 412, 3, 1017, 1018, 1019, 13, 153, 62, 414, - 415, 64, 65, 387, 67, 69, 251, 71, 72, 73, 3, 255, 255, 255, 1, 1022, - 1, 416, 8, 418, 419, 420, 421, 422, 423, 424, 425, 1, 394, 1, 427, 1, - 390, 1, 430, 1, 432, 1, 487, 3, 490, 490, 490, 1, 1032, 8, 153, 62, - 64, 65, 69, 251, 496, 72, 1, 501, 7, 62, 250, 64, 65, 69, 71, 154, 3, - 513, 255, 255, 2, 1022, 1037, 1, 508, 1, 520, 1, 521, 1, 522, 1, 251, - 2, 527, 529, 1, 532, 2, 65, 72, 1, 174, 1, 529, 5, 62, 535, 536, 70, - 72, 2, 537, 538, 4, 539, 245, 540, 201, 1, 541, 1, 542, 1, 545, 1, 69, - 2, 538, 548, 1, 552, 2, 566, 567, 2, 574, 575, 3, 576, 576, 576, 3, - 577, 577, 577, 3, 578, 578, 578, 3, 1060, 1061, 1062, 5, 65, 535, 69, - 251, 71, 1, 580, 3, 581, 558, 569, 1, 582, 2, 527, 551, 5, 584, 585, - 537, 538, 548, 2, 590, 575, 2, 635, 636, 3, 635, 638, 636, 3, 639, - 639, 639, 3, 606, 606, 606, 2, 1073, 1074, 3, 633, 637, 634, 1, 595, - 5, 62, 65, 387, 251, 73, 3, 643, 643, 643, 1, 1079, 2, 615, 617, 1, - 645, 1, 664, 2, 62, 64, 3, 681, 681, 681, 4, 1017, 1085, 1074, 1032, - 1, 62, 3, 363, 363, 363, 3, 683, 683, 683, 2, 1088, 1089, 1, 685, 1, - 1017, 1, 684, 9, 62, 64, 65, 691, 67, 69, 71, 496, 73, 15, 153, 62, - 414, 415, 64, 67, 68, 709, 69, 251, 71, 154, 710, 496, 72, 1, 711, 5, - 254, 584, 155, 713, 174, 2, 714, 715, 1, 717, 1, 763 + 224, 1, 250, 1, 251, 1, 252, 1, 253, 3, 254, 169, 79, 2, 225, 226, 1, + 255, 9, 153, 62, 257, 68, 69, 258, 71, 154, 72, 3, 259, 259, 259, 1, + 1015, 4, 261, 155, 173, 174, 4, 238, 240, 220, 239, 2, 246, 237, 6, + 175, 176, 177, 180, 178, 182, 2, 219, 18, 1, 274, 1, 276, 2, 368, 369, + 2, 54, 369, 7, 62, 64, 65, 67, 69, 72, 73, 1, 366, 2, 379, 174, 1, + 365, 43, 324, 364, 358, 326, 342, 340, 310, 314, 304, 308, 302, 300, + 360, 306, 332, 338, 294, 298, 296, 286, 284, 334, 280, 282, 352, 316, + 320, 322, 318, 344, 348, 350, 346, 328, 312, 336, 362, 356, 290, 292, + 288, 354, 330, 2, 390, 391, 6, 393, 394, 395, 396, 397, 398, 3, 425, + 425, 425, 3, 426, 426, 426, 3, 427, 427, 427, 3, 1033, 1034, 1035, 13, + 153, 62, 429, 430, 64, 65, 402, 67, 69, 258, 71, 72, 73, 3, 262, 262, + 262, 1, 1038, 1, 431, 8, 433, 434, 435, 436, 437, 438, 439, 440, 1, + 409, 1, 442, 1, 405, 1, 445, 1, 447, 1, 502, 3, 505, 505, 505, 1, + 1048, 8, 153, 62, 64, 65, 69, 258, 511, 72, 1, 516, 7, 62, 257, 64, + 65, 69, 71, 154, 3, 528, 262, 262, 2, 1038, 1053, 1, 523, 1, 535, 1, + 536, 1, 537, 1, 258, 2, 542, 544, 1, 547, 2, 65, 72, 1, 174, 1, 544, + 5, 62, 550, 551, 70, 72, 2, 552, 553, 4, 554, 250, 555, 201, 1, 556, + 1, 557, 1, 560, 1, 69, 2, 553, 563, 1, 567, 2, 581, 582, 2, 589, 590, + 3, 591, 591, 591, 3, 592, 592, 592, 3, 593, 593, 593, 3, 1076, 1077, + 1078, 5, 65, 550, 69, 258, 71, 1, 595, 3, 596, 573, 584, 1, 597, 2, + 542, 566, 5, 599, 600, 552, 553, 563, 2, 605, 590, 2, 650, 651, 3, + 650, 653, 651, 3, 654, 654, 654, 3, 621, 621, 621, 2, 1089, 1090, 3, + 648, 652, 649, 1, 610, 5, 62, 65, 402, 258, 73, 3, 658, 658, 658, 1, + 1095, 2, 630, 632, 1, 660, 1, 679, 2, 62, 64, 3, 696, 696, 696, 4, + 1033, 1101, 1090, 1048, 1, 62, 3, 378, 378, 378, 3, 698, 698, 698, 2, + 1104, 1105, 1, 700, 1, 1033, 1, 699, 9, 62, 64, 65, 706, 67, 69, 71, + 511, 73, 15, 153, 62, 429, 430, 64, 67, 68, 724, 69, 258, 71, 154, + 725, 511, 72, 1, 726, 5, 261, 599, 155, 728, 174, 2, 729, 730, 1, 732, + 1, 778 }; const int CPyLit_FrozenSet[] = {0}; CPyModule *CPyModule_faster_ens____normalization__internal = NULL; @@ -129887,6 +132890,7 @@ CPyModule *CPyModule_faster_ens___constants; PyObject *CPyStatic_faster_ens___constants___globals; PyObject *CPyStatic_faster_ens___utils___globals; CPyModule *CPyModule_datetime; +CPyModule *CPyModule_functools; CPyModule *CPyModule_warnings; CPyModule *CPyModule_faster_eth_utils; CPyModule *CPyModule_faster_web3; @@ -130109,6 +133113,15 @@ PyObject *CPyStatic_faster_ens___constants___ENS_CONTENT_HASH_INTERFACE_ID = NUL PyObject *CPyStatic_faster_ens___constants___ENS_MULTICHAIN_ADDRESS_INTERFACE_ID = NULL; PyObject *CPyStatic_faster_ens___constants___ENS_EXTENDED_RESOLVER_INTERFACE_ID = NULL; char CPyDef_faster_ens___constants_____top_level__(void); +PyTypeObject *CPyType_faster_ens___utils___sha3_text_obj; +PyObject *CPyDef_faster_ens___utils___sha3_text_obj(void); +CPyThreadLocal faster_ens___utils___sha3_text_objObject *faster_ens___utils___sha3_text_obj_free_instance; +PyTypeObject *CPyType_faster_ens___utils___is_none_or_zero_address_obj; +PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj(void); +CPyThreadLocal faster_ens___utils___is_none_or_zero_address_objObject *faster_ens___utils___is_none_or_zero_address_obj_free_instance; +PyTypeObject *CPyType_faster_ens___utils___is_empty_name_obj; +PyObject *CPyDef_faster_ens___utils___is_empty_name_obj(void); +CPyThreadLocal faster_ens___utils___is_empty_name_objObject *faster_ens___utils___is_empty_name_obj_free_instance; PyObject *CPyDef_faster_ens___utils___Web3(void); PyObject *CPyPy_faster_ens___utils___Web3(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); PyObject *CPyDef_faster_ens___utils___init_web3(PyObject *cpy_r_provider, PyObject *cpy_r_middleware); @@ -130125,8 +133138,22 @@ char CPyDef_faster_ens___utils___is_valid_name(PyObject *cpy_r_name); PyObject *CPyPy_faster_ens___utils___is_valid_name(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); PyObject *CPyDef_faster_ens___utils___to_utc_datetime(double cpy_r_timestamp); PyObject *CPyPy_faster_ens___utils___to_utc_datetime(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_sha3_text__(PyObject *cpy_r_val); +PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_sha3_text__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils___sha3_text_obj_____init__(PyObject *cpy_r___mypyc_self__); +PyObject *CPyPy_faster_ens___utils___sha3_text_obj_____init__(PyObject *self, PyObject *args, PyObject *kw); +PyObject *CPyDef_faster_ens___utils___sha3_text_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_val); +PyObject *CPyPy_faster_ens___utils___sha3_text_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils___sha3_text_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +PyObject *CPyPy_faster_ens___utils___sha3_text_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils___sha3_text_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func); +PyObject *CPyPy_faster_ens___utils___sha3_text_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); PyObject *CPyDef_faster_ens___utils___sha3_text(PyObject *cpy_r_val); PyObject *CPyPy_faster_ens___utils___sha3_text(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils___sha3_text_str(PyObject *cpy_r_val); +PyObject *CPyPy_faster_ens___utils___sha3_text_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils___sha3_text_bytes(PyObject *cpy_r_val); +PyObject *CPyPy_faster_ens___utils___sha3_text_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); PyObject *CPyDef_faster_ens___utils___label_to_hash(PyObject *cpy_r_label); PyObject *CPyPy_faster_ens___utils___label_to_hash(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); PyObject *CPyDef_faster_ens___utils___normal_name_to_hash(PyObject *cpy_r_name); @@ -130141,10 +133168,40 @@ CPyTagged CPyDef_faster_ens___utils___estimate_auction_start_gas(PyObject *cpy_r PyObject *CPyPy_faster_ens___utils___estimate_auction_start_gas(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); PyObject *CPyDef_faster_ens___utils___assert_signer_in_modifier_kwargs(PyObject *cpy_r_modifier_kwargs); PyObject *CPyPy_faster_ens___utils___assert_signer_in_modifier_kwargs(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_is_none_or_zero_address__(PyObject *cpy_r_addr); +PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_is_none_or_zero_address__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____init__(PyObject *cpy_r___mypyc_self__); +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____init__(PyObject *self, PyObject *args, PyObject *kw); +char CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_addr); +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func); +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); char CPyDef_faster_ens___utils___is_none_or_zero_address(PyObject *cpy_r_addr); PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils___is_none_or_zero_address_none(char cpy_r_addr); +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_none(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils___is_none_or_zero_address_str(PyObject *cpy_r_addr); +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils___is_none_or_zero_address_bytes(PyObject *cpy_r_addr); +PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_is_empty_name__(PyObject *cpy_r_name); +PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_is_empty_name__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils___is_empty_name_obj_____init__(PyObject *cpy_r___mypyc_self__); +PyObject *CPyPy_faster_ens___utils___is_empty_name_obj_____init__(PyObject *self, PyObject *args, PyObject *kw); +char CPyDef_faster_ens___utils___is_empty_name_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_name); +PyObject *CPyPy_faster_ens___utils___is_empty_name_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils___is_empty_name_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +PyObject *CPyPy_faster_ens___utils___is_empty_name_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +PyObject *CPyDef_faster_ens___utils___is_empty_name_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func); +PyObject *CPyPy_faster_ens___utils___is_empty_name_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); char CPyDef_faster_ens___utils___is_empty_name(PyObject *cpy_r_name); PyObject *CPyPy_faster_ens___utils___is_empty_name(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils___is_empty_name_none(char cpy_r_name); +PyObject *CPyPy_faster_ens___utils___is_empty_name_none(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +char CPyDef_faster_ens___utils___is_empty_name_str(PyObject *cpy_r_name); +PyObject *CPyPy_faster_ens___utils___is_empty_name_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); char CPyDef_faster_ens___utils___is_valid_ens_name(PyObject *cpy_r_ens_name); PyObject *CPyPy_faster_ens___utils___is_valid_ens_name(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); PyObject *CPyDef_faster_ens___utils___init_async_web3(PyObject *cpy_r_provider, PyObject *cpy_r_middleware); diff --git a/build/__native_f5f0329a7cb679764f9a.h b/build/__native_f5f0329a7cb679764f9a.h index 2466872076..6b95be3a5e 100644 --- a/build/__native_f5f0329a7cb679764f9a.h +++ b/build/__native_f5f0329a7cb679764f9a.h @@ -163,6 +163,30 @@ typedef struct { PyObject *__reverse_resolver_contract; } faster_ens___base_ens___BaseENSObject; +typedef struct { + PyObject_HEAD + CPyVTableItem *vtable; + vectorcallfunc vectorcall; + PyObject *_registry; + PyObject *_dispatch_cache; +} faster_ens___utils___sha3_text_objObject; + +typedef struct { + PyObject_HEAD + CPyVTableItem *vtable; + vectorcallfunc vectorcall; + PyObject *_registry; + PyObject *_dispatch_cache; +} faster_ens___utils___is_none_or_zero_address_objObject; + +typedef struct { + PyObject_HEAD + CPyVTableItem *vtable; + vectorcallfunc vectorcall; + PyObject *_registry; + PyObject *_dispatch_cache; +} faster_ens___utils___is_empty_name_objObject; + typedef struct { PyObject_HEAD CPyVTableItem *vtable; diff --git a/build/__native_internal_f5f0329a7cb679764f9a.h b/build/__native_internal_f5f0329a7cb679764f9a.h index a109f3e448..6835470be9 100644 --- a/build/__native_internal_f5f0329a7cb679764f9a.h +++ b/build/__native_internal_f5f0329a7cb679764f9a.h @@ -6,7 +6,7 @@ int CPyGlobalsInit(void); -extern PyObject *CPyStatics[1101]; +extern PyObject *CPyStatics[1117]; extern const char * const CPyLit_Str[]; extern const char * const CPyLit_Bytes[]; extern const char * const CPyLit_Int[]; @@ -43,6 +43,7 @@ extern CPyModule *CPyModule_faster_ens___constants; extern PyObject *CPyStatic_faster_ens___constants___globals; extern PyObject *CPyStatic_faster_ens___utils___globals; extern CPyModule *CPyModule_datetime; +extern CPyModule *CPyModule_functools; extern CPyModule *CPyModule_warnings; extern CPyModule *CPyModule_faster_eth_utils; extern CPyModule *CPyModule_faster_web3; @@ -265,6 +266,15 @@ extern PyObject *CPyStatic_faster_ens___constants___ENS_CONTENT_HASH_INTERFACE_I extern PyObject *CPyStatic_faster_ens___constants___ENS_MULTICHAIN_ADDRESS_INTERFACE_ID; extern PyObject *CPyStatic_faster_ens___constants___ENS_EXTENDED_RESOLVER_INTERFACE_ID; extern char CPyDef_faster_ens___constants_____top_level__(void); +extern PyTypeObject *CPyType_faster_ens___utils___sha3_text_obj; +extern PyObject *CPyDef_faster_ens___utils___sha3_text_obj(void); +extern CPyThreadLocal faster_ens___utils___sha3_text_objObject *faster_ens___utils___sha3_text_obj_free_instance; +extern PyTypeObject *CPyType_faster_ens___utils___is_none_or_zero_address_obj; +extern PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj(void); +extern CPyThreadLocal faster_ens___utils___is_none_or_zero_address_objObject *faster_ens___utils___is_none_or_zero_address_obj_free_instance; +extern PyTypeObject *CPyType_faster_ens___utils___is_empty_name_obj; +extern PyObject *CPyDef_faster_ens___utils___is_empty_name_obj(void); +extern CPyThreadLocal faster_ens___utils___is_empty_name_objObject *faster_ens___utils___is_empty_name_obj_free_instance; extern PyObject *CPyDef_faster_ens___utils___Web3(void); extern PyObject *CPyPy_faster_ens___utils___Web3(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern PyObject *CPyDef_faster_ens___utils___init_web3(PyObject *cpy_r_provider, PyObject *cpy_r_middleware); @@ -281,8 +291,22 @@ extern char CPyDef_faster_ens___utils___is_valid_name(PyObject *cpy_r_name); extern PyObject *CPyPy_faster_ens___utils___is_valid_name(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern PyObject *CPyDef_faster_ens___utils___to_utc_datetime(double cpy_r_timestamp); extern PyObject *CPyPy_faster_ens___utils___to_utc_datetime(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_sha3_text__(PyObject *cpy_r_val); +extern PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_sha3_text__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils___sha3_text_obj_____init__(PyObject *cpy_r___mypyc_self__); +extern PyObject *CPyPy_faster_ens___utils___sha3_text_obj_____init__(PyObject *self, PyObject *args, PyObject *kw); +extern PyObject *CPyDef_faster_ens___utils___sha3_text_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_val); +extern PyObject *CPyPy_faster_ens___utils___sha3_text_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils___sha3_text_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +extern PyObject *CPyPy_faster_ens___utils___sha3_text_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils___sha3_text_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func); +extern PyObject *CPyPy_faster_ens___utils___sha3_text_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern PyObject *CPyDef_faster_ens___utils___sha3_text(PyObject *cpy_r_val); extern PyObject *CPyPy_faster_ens___utils___sha3_text(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils___sha3_text_str(PyObject *cpy_r_val); +extern PyObject *CPyPy_faster_ens___utils___sha3_text_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils___sha3_text_bytes(PyObject *cpy_r_val); +extern PyObject *CPyPy_faster_ens___utils___sha3_text_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern PyObject *CPyDef_faster_ens___utils___label_to_hash(PyObject *cpy_r_label); extern PyObject *CPyPy_faster_ens___utils___label_to_hash(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern PyObject *CPyDef_faster_ens___utils___normal_name_to_hash(PyObject *cpy_r_name); @@ -297,10 +321,40 @@ extern CPyTagged CPyDef_faster_ens___utils___estimate_auction_start_gas(PyObject extern PyObject *CPyPy_faster_ens___utils___estimate_auction_start_gas(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern PyObject *CPyDef_faster_ens___utils___assert_signer_in_modifier_kwargs(PyObject *cpy_r_modifier_kwargs); extern PyObject *CPyPy_faster_ens___utils___assert_signer_in_modifier_kwargs(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_is_none_or_zero_address__(PyObject *cpy_r_addr); +extern PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_is_none_or_zero_address__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____init__(PyObject *cpy_r___mypyc_self__); +extern PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____init__(PyObject *self, PyObject *args, PyObject *kw); +extern char CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_addr); +extern PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +extern PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils___is_none_or_zero_address_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func); +extern PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern char CPyDef_faster_ens___utils___is_none_or_zero_address(PyObject *cpy_r_addr); extern PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils___is_none_or_zero_address_none(char cpy_r_addr); +extern PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_none(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils___is_none_or_zero_address_str(PyObject *cpy_r_addr); +extern PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils___is_none_or_zero_address_bytes(PyObject *cpy_r_addr); +extern PyObject *CPyPy_faster_ens___utils___is_none_or_zero_address_bytes(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils_____mypyc_singledispatch_main_function_is_empty_name__(PyObject *cpy_r_name); +extern PyObject *CPyPy_faster_ens___utils_____mypyc_singledispatch_main_function_is_empty_name__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils___is_empty_name_obj_____init__(PyObject *cpy_r___mypyc_self__); +extern PyObject *CPyPy_faster_ens___utils___is_empty_name_obj_____init__(PyObject *self, PyObject *args, PyObject *kw); +extern char CPyDef_faster_ens___utils___is_empty_name_obj_____call__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_name); +extern PyObject *CPyPy_faster_ens___utils___is_empty_name_obj_____call__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils___is_empty_name_obj_____get__(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_instance, PyObject *cpy_r_owner); +extern PyObject *CPyPy_faster_ens___utils___is_empty_name_obj_____get__(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern PyObject *CPyDef_faster_ens___utils___is_empty_name_obj___register(PyObject *cpy_r___mypyc_self__, PyObject *cpy_r_cls, PyObject *cpy_r_func); +extern PyObject *CPyPy_faster_ens___utils___is_empty_name_obj___register(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern char CPyDef_faster_ens___utils___is_empty_name(PyObject *cpy_r_name); extern PyObject *CPyPy_faster_ens___utils___is_empty_name(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils___is_empty_name_none(char cpy_r_name); +extern PyObject *CPyPy_faster_ens___utils___is_empty_name_none(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); +extern char CPyDef_faster_ens___utils___is_empty_name_str(PyObject *cpy_r_name); +extern PyObject *CPyPy_faster_ens___utils___is_empty_name_str(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern char CPyDef_faster_ens___utils___is_valid_ens_name(PyObject *cpy_r_ens_name); extern PyObject *CPyPy_faster_ens___utils___is_valid_ens_name(PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames); extern PyObject *CPyDef_faster_ens___utils___init_async_web3(PyObject *cpy_r_provider, PyObject *cpy_r_middleware);