File py313.patch of Package python-numba

Overview Repositories Revisions Requests Users Attributes Meta

File py313.patch of Package python-numba (Revision 27da4a8d69b219a464b17f39401fd4ac)

Currently displaying revision 27da4a8d69b219a464b17f39401fd4ac , Show latest

From 3e89582a41fc2712a0ce86528be98cf3dd768a23 Mon Sep 17 00:00:00 2001
From: Siu Kwan Lam <1929845+sklam@users.noreply.github.com>
Date: Tue, 16 Jan 2024 14:31:01 -0600
Subject: [PATCH 01/61] Minimal changes to get compiling

Index: numba-0.60.0/numba/_devicearray.cpp
===================================================================
--- numba-0.60.0.orig/numba/_devicearray.cpp
+++ numba-0.60.0/numba/_devicearray.cpp
@@ -96,7 +96,7 @@ PyTypeObject DeviceArrayType = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
Index: numba-0.60.0/numba/_dispatcher.cpp
===================================================================
--- numba-0.60.0.orig/numba/_dispatcher.cpp
+++ numba-0.60.0/numba/_dispatcher.cpp
@@ -27,7 +27,7 @@
  *
  */
 
-#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 12)
+#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 13)
 
 #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
@@ -39,7 +39,10 @@
 #  undef HAVE_STD_ATOMIC
 #endif
 #undef _PyGC_FINALIZED
-#include "internal/pycore_atomic.h"
+
+#if (PY_MINOR_VERSION == 12)
+    #include "internal/pycore_atomic.h"
+#endif
 #include "internal/pycore_interp.h"
 #include "internal/pycore_pyerrors.h"
 #include "internal/pycore_instruments.h"
@@ -780,7 +783,7 @@ call_cfunc(Dispatcher *self, PyObject *c
     }
 }
 
-#elif (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 12)
+#elif (PY_MAJOR_VERSION >= 3) && ((PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13))
 
 // Python 3.12 has a completely new approach to tracing and profiling due to
 // the new `sys.monitoring` system.
@@ -1589,7 +1592,7 @@ static PyTypeObject DispatcherType = {
     0,                                           /* tp_version_tag */
     0,                                           /* tp_finalize */
     0,                                           /* tp_vectorcall */
-#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12)
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 13)
 /* This was introduced first in 3.12
  * https://github.com/python/cpython/issues/91051
  */
@@ -1599,7 +1602,7 @@ static PyTypeObject DispatcherType = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
Index: numba-0.60.0/numba/_dynfunc.c
===================================================================
--- numba-0.60.0.orig/numba/_dynfunc.c
+++ numba-0.60.0/numba/_dynfunc.c
@@ -7,6 +7,12 @@
 
 #include <string.h>
 
+
+// if python version is 3.13
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13)
+    #include "pythoncapi_compat.h"
+    #define _Py_IsFinalizing Py_IsFinalizing
+#endif
 /* NOTE: EnvironmentObject and ClosureObject must be kept in sync with
  * the definitions in numba/targets/base.py (EnvBody and ClosureBody).
  */
@@ -146,7 +152,7 @@ static PyTypeObject EnvironmentType = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
@@ -265,7 +271,7 @@ static PyTypeObject ClosureType = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
@@ -485,7 +491,7 @@ static PyTypeObject GeneratorType = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
Index: numba-0.60.0/numba/_helperlib.c
===================================================================
--- numba-0.60.0.orig/numba/_helperlib.c
+++ numba-0.60.0/numba/_helperlib.c
@@ -293,7 +293,7 @@ numba_recreate_record(void *pdata, int s
         return NULL;
     }
 
-    numpy = PyImport_ImportModuleNoBlock("numpy");
+    numpy = PyImport_ImportModule("numpy");
     if (!numpy) goto CLEANUP;
 
     numpy_record = PyObject_GetAttrString(numpy, "record");
@@ -833,7 +833,7 @@ static void traceback_add(const char *fu
     if (!frame)
         goto error;
 
-#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) /* 3.12 */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13) /* 3.12 or 3.13 */
 #elif (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 11) /* 3.11 */
 
     /* unsafe cast to our copy of _frame to access the f_lineno field */
@@ -851,7 +851,7 @@ static void traceback_add(const char *fu
     Py_DECREF(frame);
     return;
 
-#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) /* 3.12 */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13) /* 3.12 or 3.13 */
 error:
     _PyErr_ChainExceptions1(exc);
 #elif (PY_MAJOR_VERSION == 3) && ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11)) /* 3.11 and below */
Index: numba-0.60.0/numba/_pymodule.h
===================================================================
--- numba-0.60.0.orig/numba/_pymodule.h
+++ numba-0.60.0/numba/_pymodule.h
@@ -29,4 +29,7 @@
         PyObject_SetAttrString(m, #name, tmp); \
         Py_DECREF(tmp); } while (0)
 
+
+#define NB_SUPPORTED_PYTHON_MINOR ((PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13))
+
 #endif /* NUMBA_PY_MODULE_H_ */
Index: numba-0.60.0/numba/_typeof.cpp
===================================================================
--- numba-0.60.0.orig/numba/_typeof.cpp
+++ numba-0.60.0/numba/_typeof.cpp
@@ -16,6 +16,14 @@
     #include <numpy/npy_2_compat.h>
 #endif
 
+#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 13)
+    #ifndef Py_BUILD_CORE
+        #define Py_BUILD_CORE 1
+    #endif
+    #include "internal/pycore_setobject.h"  // _PySet_NextEntry()
+#endif
+
+
 /* Cached typecodes for basic scalar types */
 static int tc_int8;
 static int tc_int16;
Index: numba-0.60.0/numba/core/runtime/_nrt_python.c
===================================================================
--- numba-0.60.0.orig/numba/core/runtime/_nrt_python.c
+++ numba-0.60.0/numba/core/runtime/_nrt_python.c
@@ -229,7 +229,7 @@ static PyTypeObject MemInfoType = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
Index: numba-0.60.0/numba/experimental/jitclass/_box.c
===================================================================
--- numba-0.60.0.orig/numba/experimental/jitclass/_box.c
+++ numba-0.60.0/numba/experimental/jitclass/_box.c
@@ -110,7 +110,7 @@ static PyTypeObject BoxType = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
Index: numba-0.60.0/numba/mviewbuf.c
===================================================================
--- numba-0.60.0.orig/numba/mviewbuf.c
+++ numba-0.60.0/numba/mviewbuf.c
@@ -344,7 +344,7 @@ static PyTypeObject MemAllocType = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
Index: numba-0.60.0/numba/np/ufunc/_internal.c
===================================================================
--- numba-0.60.0.orig/numba/np/ufunc/_internal.c
+++ numba-0.60.0/numba/np/ufunc/_internal.c
@@ -100,7 +100,7 @@ PyTypeObject PyUFuncCleaner_Type = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
@@ -753,7 +753,7 @@ PyTypeObject PyDUFunc_Type = {
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
 #if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
 #error "Python minor version is not supported."
 #endif
 #else
Index: numba-0.60.0/numba/core/bytecode.py
===================================================================
--- numba-0.60.0.orig/numba/core/bytecode.py
+++ numba-0.60.0/numba/core/bytecode.py
@@ -9,7 +9,7 @@ from numba.core import errors, utils, se
 from numba.core.utils import PYVERSION
 
 
-if PYVERSION in ((3, 12), ):
+if PYVERSION in ((3, 12), (3, 13)):
     from opcode import _inline_cache_entries
     # Instruction/opcode length in bytes
     INSTR_LEN = 2
@@ -104,7 +104,12 @@ class ByteCodeInst(object):
         # https://bugs.python.org/issue27129
         # https://github.com/python/cpython/pull/25069
         assert self.is_jump
-        if PYVERSION in ((3, 12), ):
+        if PYVERSION in ((3, 13),):
+            if self.opcode in (dis.opmap[k]
+                               for k in ["JUMP_BACKWARD",
+                                         "JUMP_BACKWARD_NO_INTERRUPT"]):
+                return self.next - (self.arg * 2)
+        elif PYVERSION in ((3, 12),):
             if self.opcode in (dis.opmap[k]
                                for k in ["JUMP_BACKWARD"]):
                 return self.offset - (self.arg - 1) * 2
@@ -121,7 +126,7 @@ class ByteCodeInst(object):
         else:
             raise NotImplementedError(PYVERSION)
 
-        if PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
             if self.opcode in JREL_OPS:
                 return self.next + self.arg * 2
             else:
@@ -160,7 +165,7 @@ OPCODE_NOP = dis.opname.index('NOP')
 
 
 # Adapted from Lib/dis.py
-def _unpack_opargs(code):
+def _unpack_opargs_pre_3_13(code):
     """
     Returns a 4-int-tuple of
     (bytecode offset, opcode, argument, offset of next bytecode).
@@ -176,7 +181,7 @@ def _unpack_opargs(code):
             for j in range(ARG_LEN):
                 arg |= code[i + j] << (8 * j)
             i += ARG_LEN
-            if PYVERSION in ((3, 12), ):
+            if PYVERSION in ((3, 12),):
                 # Python 3.12 introduced cache slots. We need to account for
                 # cache slots when we determine the offset of the next opcode.
                 # The number of cache slots is specific to each opcode and can
@@ -200,7 +205,7 @@ def _unpack_opargs(code):
         else:
             arg = None
             i += NO_ARG_LEN
-            if PYVERSION in ((3, 12), ):
+            if PYVERSION in ((3, 12),):
                 # Python 3.12 introduced cache slots. We need to account for
                 # cache slots when we determine the offset of the next opcode.
                 # The number of cache slots is specific to each opcode and can
@@ -216,6 +221,80 @@ def _unpack_opargs(code):
         offset = i  # Mark inst offset at first extended
 
 
+# Adapted from Lib/dis.py
+def _unpack_opargs_pre_3_13(code):
+    """
+    Returns a 4-int-tuple of
+    (bytecode offset, opcode, argument, offset of next bytecode).
+    """
+    extended_arg = 0
+    n = len(code)
+    offset = i = 0
+    while i < n:
+        op = code[i]
+        i += CODE_LEN
+        if op >= HAVE_ARGUMENT:
+            arg = code[i] | extended_arg
+            for j in range(ARG_LEN):
+                arg |= code[i + j] << (8 * j)
+            i += ARG_LEN
+            if PYVERSION in ((3, 12),):
+                # Python 3.12 introduced cache slots. We need to account for
+                # cache slots when we determine the offset of the next opcode.
+                # The number of cache slots is specific to each opcode and can
+                # be looked up in the _inline_cache_entries dictionary.
+                i += _inline_cache_entries[op] * INSTR_LEN
+            elif PYVERSION in ((3, 10), (3, 11)):
+                pass
+            else:
+                raise NotImplementedError(PYVERSION)
+            if op == EXTENDED_ARG:
+                # This is a deviation from what dis does...
+                # In python 3.11 it seems like EXTENDED_ARGs appear more often
+                # and are also used as jump targets. So as to not have to do
+                # "book keeping" for where EXTENDED_ARGs have been "skipped"
+                # they are replaced with NOPs so as to provide a legal jump
+                # target and also ensure that the bytecode offsets are correct.
+                yield (offset, OPCODE_NOP, arg, i)
+                extended_arg = arg << 8 * ARG_LEN
+                offset = i
+                continue
+        else:
+            arg = None
+            i += NO_ARG_LEN
+            if PYVERSION in ((3, 12),):
+                # Python 3.12 introduced cache slots. We need to account for
+                # cache slots when we determine the offset of the next opcode.
+                # The number of cache slots is specific to each opcode and can
+                # be looked up in the _inline_cache_entries dictionary.
+                i += _inline_cache_entries[op] * INSTR_LEN
+            elif PYVERSION in ((3, 10), (3, 11)):
+                pass
+            else:
+                raise NotImplementedError(PYVERSION)
+
+        extended_arg = 0
+        yield (offset, op, arg, i)
+        offset = i  # Mark inst offset at first extended
+
+
+if PYVERSION in ((3, 13),):
+
+    def _unpack_opargs(code):
+        buf = []
+        for i, start_offset, op, arg in dis._unpack_opargs(code):
+            buf.append((start_offset, op, arg))
+        for i, (start_offset, op, arg) in enumerate(buf):
+            if i + 1 < len(buf):
+                next_offset = buf[i + 1][0]
+            else:
+                next_offset = len(code)
+            yield (start_offset, op, arg, next_offset)
+
+else:
+    _unpack_opargs = _unpack_opargs_pre_3_13
+
+
 def _patched_opargs(bc_stream):
     """Patch the bytecode stream.
 
@@ -298,7 +377,7 @@ class _ByteCode(object):
         # Start with first bytecode's lineno
         known = code.co_firstlineno
         for inst in table.values():
-            if inst.lineno >= 0:
+            if inst.lineno is not None and inst.lineno >= 0:
                 known = inst.lineno
             else:
                 inst.lineno = known
@@ -363,7 +442,7 @@ class _ByteCode(object):
 
 
 def _fix_LOAD_GLOBAL_arg(arg):
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         return arg >> 1
     elif PYVERSION in ((3, 9), (3, 10)):
         return arg
@@ -452,8 +531,15 @@ class ByteCodePy312(ByteCodePy311):
             entirely along with the dead exceptions that it points to.
             A pair of exception that sandwiches these exception will
             also be merged into a single exception.
-        """
 
+            Update for Python 3.13, the ending of the pattern has a extra
+            POP_TOP:
+
+            ...
+            END_FOR
+            POP_TOP
+            SWAP(2)
+        """
         def pop_and_merge_exceptions(entries: list,
                                      entry_to_remove: _ExceptionTableEntry):
             lower_entry_idx = entries.index(entry_to_remove) - 1
@@ -505,17 +591,34 @@ class ByteCodePy312(ByteCodePy311):
                 if not next_inst.opname == "FOR_ITER":
                     continue
 
-                # Check end of pattern, two instructions.
-                # Check for the corresponding END_FOR, exception table end is
-                # non-inclusive, so subtract one.
-                index = self.ordered_offsets.index(entry.end)
-                curr_inst = self.table[self.ordered_offsets[index - 1]]
-                if not curr_inst.opname == "END_FOR":
-                    continue
-                # END_FOR must be followed by SWAP(2)
-                next_inst = self.table[self.ordered_offsets[index]]
-                if not next_inst.opname == "SWAP" and next_inst.arg == 2:
-                    continue
+                if PYVERSION == (3, 13):
+                    # Check end of pattern, two instructions.
+                    # Check for the corresponding END_FOR, exception table end
+                    # is non-inclusive, so subtract one.
+                    index = self.ordered_offsets.index(entry.end)
+                    curr_inst = self.table[self.ordered_offsets[index - 2]]
+                    if not curr_inst.opname == "END_FOR":
+                        continue
+                    next_inst = self.table[self.ordered_offsets[index - 1]]
+                    if not next_inst.opname == "POP_TOP":
+                        continue
+                    # END_FOR must be followed by SWAP(2)
+                    next_inst = self.table[self.ordered_offsets[index]]
+                    if not next_inst.opname == "SWAP" and next_inst.arg == 2:
+                        continue
+                else:
+                    assert PYVERSION < (3, 13)
+                    # Check end of pattern, two instructions.
+                    # Check for the corresponding END_FOR, exception table end
+                    # is non-inclusive, so subtract one.
+                    index = self.ordered_offsets.index(entry.end)
+                    curr_inst = self.table[self.ordered_offsets[index - 1]]
+                    if not curr_inst.opname == "END_FOR":
+                        continue
+                    # END_FOR must be followed by SWAP(2)
+                    next_inst = self.table[self.ordered_offsets[index]]
+                    if not next_inst.opname == "SWAP" and next_inst.arg == 2:
+                        continue
                 # If all conditions are met that means this exception entry
                 # is for a list/dict/set comprehension and can be removed.
                 # Also if there exist exception entries above and below this
@@ -528,7 +631,7 @@ class ByteCodePy312(ByteCodePy311):
 
 if PYVERSION == (3, 11):
     ByteCode = ByteCodePy311
-elif PYVERSION == (3, 12):
+elif PYVERSION in ((3, 12), (3, 13),):
     ByteCode = ByteCodePy312
 elif PYVERSION < (3, 11):
     ByteCode = _ByteCode
Index: numba-0.60.0/numba/core/byteflow.py
===================================================================
--- numba-0.60.0.orig/numba/core/byteflow.py
+++ numba-0.60.0/numba/core/byteflow.py
@@ -10,7 +10,7 @@ from functools import total_ordering
 from numba.core.utils import UniqueDict, PYVERSION, ALL_BINOPS_TO_OPERATORS
 from numba.core.controlflow import NEW_BLOCKERS, CFGraph
 from numba.core.ir import Loc
-from numba.core.errors import UnsupportedError
+from numba.core.errors import UnsupportedBytecodeError
 
 
 _logger = logging.getLogger(__name__)
@@ -24,7 +24,7 @@ _NO_RAISE_OPS = frozenset({
     'PRECALL',
 })
 
-if PYVERSION in ((3, 12), ):
+if PYVERSION in ((3, 12), (3, 13)):
     from enum import Enum
 
     # Operands for CALL_INTRINSIC_1
@@ -149,7 +149,7 @@ class Flow(object):
             self.block_infos[state.pc_initial] = si = adapt_state_infos(state)
             _logger.debug("block_infos %s:\n%s", state, si)
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def _run_handle_exception(self, runner, state):
             if not state.in_with() and (
                     state.has_active_try() and
@@ -312,7 +312,7 @@ class Flow(object):
                 msg = ("The 'with (context manager) as "
                        "(variable):' construct is not "
                        "supported.")
-                raise UnsupportedError(msg)
+                raise UnsupportedBytecodeError(msg)
 
 
 def _is_null_temp_reg(reg):
@@ -331,7 +331,7 @@ class TraceRunner(object):
         return Loc(self.debug_filename, lineno)
 
     def dispatch(self, state):
-        if PYVERSION in ((3, 11), (3, 12)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
             if state._blockstack:
                 state: State
                 while state._blockstack:
@@ -354,7 +354,8 @@ class TraceRunner(object):
             fn(state, inst)
         else:
             msg = "Use of unsupported opcode (%s) found" % inst.opname
-            raise UnsupportedError(msg, loc=self.get_debug_loc(inst.lineno))
+            raise UnsupportedBytecodeError(msg,
+                                           loc=self.get_debug_loc(inst.lineno))
 
     def _adjust_except_stack(self, state):
         """
@@ -405,6 +406,15 @@ class TraceRunner(object):
         state.push(state.make_temp())
         state.append(inst)
 
+    if PYVERSION in ((3, 13),):
+        def op_FORMAT_SIMPLE(self, state, inst):
+            assert PYVERSION == (3, 13)
+            value = state.pop()
+            strvar = state.make_temp()
+            res = state.make_temp()
+            state.append(inst, value=value, res=res, strvar=strvar)
+            state.push(res)
+
     def op_FORMAT_VALUE(self, state, inst):
         """
         FORMAT_VALUE(flags): flags argument specifies format spec which is
@@ -415,7 +425,8 @@ class TraceRunner(object):
         """
         if inst.arg != 0:
             msg = "format spec in f-strings not supported yet"
-            raise UnsupportedError(msg, loc=self.get_debug_loc(inst.lineno))
+            raise UnsupportedBytecodeError(msg,
+                                           loc=self.get_debug_loc(inst.lineno))
         value = state.pop()
         strvar = state.make_temp()
         res = state.make_temp()
@@ -442,7 +453,27 @@ class TraceRunner(object):
     def op_POP_TOP(self, state, inst):
         state.pop()
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 13),):
+        def op_TO_BOOL(self, state, inst):
+            res = state.make_temp()
+            tos = state.pop()
+            state.append(inst, val=tos, res=res)
+            state.push(res)
+
+    elif PYVERSION < (3, 13):
+        pass
+
+    if PYVERSION in ((3, 13),):
+        def op_LOAD_GLOBAL(self, state, inst):
+            # Ordering of the global value and NULL is swapped in Py3.13
+            res = state.make_temp()
+            idx = inst.arg >> 1
+            state.append(inst, idx=idx, res=res)
+            state.push(res)
+            # ignoring the NULL
+            if inst.arg & 1:
+                state.push(state.make_null())
+    elif PYVERSION in ((3, 11), (3, 12)):
         def op_LOAD_GLOBAL(self, state, inst):
             res = state.make_temp()
             idx = inst.arg >> 1
@@ -471,30 +502,89 @@ class TraceRunner(object):
         state.push(res)
 
     def op_LOAD_CONST(self, state, inst):
-        res = state.make_temp("const")
+        # append const index for interpreter to read the const value
+        res = state.make_temp("const") + f".{inst.arg}"
         state.push(res)
         state.append(inst, res=res)
 
     def op_LOAD_ATTR(self, state, inst):
         item = state.pop()
-        if PYVERSION in ((3, 12), ):
+        res = state.make_temp()
+        if PYVERSION in ((3, 13),):
+            state.push(res)  # the attr
+            if inst.arg & 1:
+                state.push(state.make_null())
+        elif PYVERSION in ((3, 12),):
             if inst.arg & 1:
                 state.push(state.make_null())
+            state.push(res)
         elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
-            pass
+            state.push(res)
         else:
             raise NotImplementedError(PYVERSION)
-        res = state.make_temp()
         state.append(inst, item=item, res=res)
-        state.push(res)
 
     def op_LOAD_FAST(self, state, inst):
-        name = state.get_varname(inst)
+        assert PYVERSION <= (3, 13)
+        if PYVERSION in ((3, 13), ):
+            try:
+                name = state.get_varname(inst)
+            except IndexError:   # oparg is out of range
+                # Handle this like a LOAD_DEREF
+                # Assume MAKE_CELL and COPY_FREE_VARS has correctly setup the
+                # states.
+                # According to https://github.com/python/cpython/blob/9ac606080a0074cdf7589d9b7c9413a73e0ddf37/Objects/codeobject.c#L730C9-L759 # noqa E501
+                # localsplus is locals + cells + freevars
+                bc = state._bytecode
+                num_varnames = len(bc.co_varnames)
+                num_freevars = len(bc.co_freevars)
+                num_cellvars = len(bc.co_cellvars)
+                max_fast_local = num_cellvars + num_freevars
+                assert 0 <= inst.arg - num_varnames < max_fast_local
+                res = state.make_temp()
+                state.append(inst, res=res, as_load_deref=True)
+                state.push(res)
+                return
+        else:
+            name = state.get_varname(inst)
         res = state.make_temp(name)
         state.append(inst, res=res)
         state.push(res)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 13),):
+        def op_LOAD_FAST_LOAD_FAST(self, state, inst):
+            oparg = inst.arg
+            oparg1 = oparg >> 4
+            oparg2 = oparg & 15
+            name1 = state.get_varname_by_arg(oparg1)
+            name2 = state.get_varname_by_arg(oparg2)
+            res1 = state.make_temp(name1)
+            res2 = state.make_temp(name2)
+            state.append(inst, res1=res1, res2=res2)
+            state.push(res1)
+            state.push(res2)
+
+        def op_STORE_FAST_LOAD_FAST(self, state, inst):
+            oparg = inst.arg
+            # oparg1 = oparg >> 4  # not needed
+            oparg2 = oparg & 15
+            store_value = state.pop()
+            load_name = state.get_varname_by_arg(oparg2)
+            load_res = state.make_temp(load_name)
+            state.append(inst, store_value=store_value, load_res=load_res)
+            state.push(load_res)
+
+        def op_STORE_FAST_STORE_FAST(self, state, inst):
+            value1 = state.pop()
+            value2 = state.pop()
+            state.append(inst, value1=value1, value2=value2)
+
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
+    if PYVERSION in ((3, 12), (3, 13)):
         op_LOAD_FAST_CHECK = op_LOAD_FAST
         op_LOAD_FAST_AND_CLEAR = op_LOAD_FAST
     elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -753,7 +843,7 @@ class TraceRunner(object):
         )
         state.push(res)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_BINARY_SLICE(self, state, inst):
             end = state.pop()
             start = state.pop()
@@ -771,7 +861,7 @@ class TraceRunner(object):
     else:
         raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_STORE_SLICE(self, state, inst):
             end = state.pop()
             start = state.pop()
@@ -804,7 +894,7 @@ class TraceRunner(object):
     op_POP_JUMP_IF_TRUE = _op_POP_JUMP_IF
     op_POP_JUMP_IF_FALSE = _op_POP_JUMP_IF
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         op_POP_JUMP_IF_NONE = _op_POP_JUMP_IF
         op_POP_JUMP_IF_NOT_NONE = _op_POP_JUMP_IF
     elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -853,6 +943,8 @@ class TraceRunner(object):
         state.append(inst)
         state.fork(pc=inst.get_jump_target())
 
+    op_JUMP_BACKWARD_NO_INTERRUPT = op_JUMP_BACKWARD
+
     def op_JUMP_ABSOLUTE(self, state, inst):
         state.append(inst)
         state.fork(pc=inst.get_jump_target())
@@ -868,7 +960,7 @@ class TraceRunner(object):
         state.append(inst, retval=state.pop(), castval=state.make_temp())
         state.terminate()
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_RETURN_CONST(self, state, inst):
             res = state.make_temp("const")
             state.append(inst, retval=res, castval=state.make_temp())
@@ -884,14 +976,14 @@ class TraceRunner(object):
         state.append(inst, value=val, res=res)
         state.push(res)
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def op_RAISE_VARARGS(self, state, inst):
             if inst.arg == 0:
                 exc = None
                 # No re-raising within a try-except block.
                 # But we allow bare reraise.
                 if state.has_active_try():
-                    raise UnsupportedError(
+                    raise UnsupportedBytecodeError(
                         "The re-raising of an exception is not yet supported.",
                         loc=self.get_debug_loc(inst.lineno),
                     )
@@ -915,7 +1007,7 @@ class TraceRunner(object):
             if inst.arg == 0:
                 exc = None
                 if in_exc_block:
-                    raise UnsupportedError(
+                    raise UnsupportedBytecodeError(
                         "The re-raising of an exception is not yet supported.",
                         loc=self.get_debug_loc(inst.lineno),
                     )
@@ -940,7 +1032,10 @@ class TraceRunner(object):
         blk = state.pop_block()
         state.reset_stack(blk['entry_stack'])
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 13),):
+        def op_END_FOR(self, state, inst):
+            state.pop()
+    elif PYVERSION in ((3, 12),):
         def op_END_FOR(self, state, inst):
             state.pop()
             state.pop()
@@ -954,7 +1049,8 @@ class TraceRunner(object):
         if inst.arg != 0:
             msg = ('Unsupported use of a bytecode related to try..finally'
                    ' or a with-context')
-            raise UnsupportedError(msg, loc=self.get_debug_loc(inst.lineno))
+            raise UnsupportedBytecodeError(msg,
+                                           loc=self.get_debug_loc(inst.lineno))
 
     def op_CALL_FINALLY(self, state, inst):
         pass
@@ -1068,7 +1164,7 @@ class TraceRunner(object):
             'FINALLY', state, next=inst.next, end=inst.get_jump_target(),
         )
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def op_POP_EXCEPT(self, state, inst):
             state.pop()
 
@@ -1076,7 +1172,7 @@ class TraceRunner(object):
         def op_POP_EXCEPT(self, state, inst):
             blk = state.pop_block()
             if blk['kind'] not in {BlockKind('EXCEPT'), BlockKind('FINALLY')}:
-                raise UnsupportedError(
+                raise UnsupportedBytecodeError(
                     f"POP_EXCEPT got an unexpected block: {blk['kind']}",
                     loc=self.get_debug_loc(inst.lineno),
                 )
@@ -1117,16 +1213,24 @@ class TraceRunner(object):
     def op_CALL(self, state, inst):
         narg = inst.arg
         args = list(reversed([state.pop() for _ in range(narg)]))
-        callable_or_firstarg = state.pop()
-        null_or_callable = state.pop()
-        if _is_null_temp_reg(null_or_callable):
-            callable = callable_or_firstarg
-        else:
-            callable = null_or_callable
-            args = [callable_or_firstarg, *args]
+        if PYVERSION == (3, 13):
+            null_or_self = state.pop()
+            # position of the callable is fixed
+            callable = state.pop()
+            if not _is_null_temp_reg(null_or_self):
+                args = [null_or_self, *args]
+            kw_names = None
+        elif PYVERSION < (3, 13):
+            callable_or_firstarg = state.pop()
+            null_or_callable = state.pop()
+            if _is_null_temp_reg(null_or_callable):
+                callable = callable_or_firstarg
+            else:
+                callable = null_or_callable
+                args = [callable_or_firstarg, *args]
+            kw_names = state.pop_kw_names()
         res = state.make_temp()
 
-        kw_names = state.pop_kw_names()
         state.append(inst, func=callable, args=args, kw_names=kw_names, res=res)
         state.push(res)
 
@@ -1152,28 +1256,67 @@ class TraceRunner(object):
         state.append(inst, func=func, args=args, names=names, res=res)
         state.push(res)
 
-    def op_CALL_FUNCTION_EX(self, state, inst):
-        if inst.arg & 1 and PYVERSION < (3, 10):
-            errmsg = "CALL_FUNCTION_EX with **kwargs not supported"
-            raise UnsupportedError(errmsg)
-        if inst.arg & 1:
-            varkwarg = state.pop()
-        else:
-            varkwarg = None
-        vararg = state.pop()
-        func = state.pop()
+    if PYVERSION in ((3, 13),):
+        def op_CALL_KW(self, state, inst):
+            narg = inst.arg
+            kw_names = state.pop()
+            args = list(reversed([state.pop() for _ in range(narg)]))
+            null_or_firstarg = state.pop()
+            callable = state.pop()
+            if not _is_null_temp_reg(null_or_firstarg):
+                args = [null_or_firstarg, *args]
 
-        if PYVERSION in ((3, 11), (3, 12)):
-            if _is_null_temp_reg(state.peek(1)):
-                state.pop() # pop NULL, it's not used
-        elif PYVERSION in ((3, 9), (3, 10)):
-            pass
-        else:
-            raise NotImplementedError(PYVERSION)
+            res = state.make_temp()
+            state.append(inst, func=callable, args=args, kw_names=kw_names,
+                         res=res)
+            state.push(res)
 
-        res = state.make_temp()
-        state.append(inst, func=func, vararg=vararg, varkwarg=varkwarg, res=res)
-        state.push(res)
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
+    if PYVERSION in ((3, 13),):
+        def op_CALL_FUNCTION_EX(self, state, inst):
+            # (func, unused, callargs, kwargs if (oparg & 1) -- result))
+            if inst.arg & 1:
+                varkwarg = state.pop()
+            else:
+                varkwarg = None
+
+            vararg = state.pop()
+            state.pop()  # unused
+            func = state.pop()
+
+            res = state.make_temp()
+            state.append(inst, func=func, vararg=vararg, varkwarg=varkwarg,
+                         res=res)
+            state.push(res)
+
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+
+        def op_CALL_FUNCTION_EX(self, state, inst):
+            if inst.arg & 1:
+                varkwarg = state.pop()
+            else:
+                varkwarg = None
+            vararg = state.pop()
+            func = state.pop()
+
+            if PYVERSION in ((3, 11), (3, 12)):
+                if _is_null_temp_reg(state.peek(1)):
+                    state.pop() # pop NULL, it's not used
+            elif PYVERSION in ((3, 9), (3, 10)):
+                pass
+            else:
+                raise NotImplementedError(PYVERSION)
+
+            res = state.make_temp()
+            state.append(inst, func=func, vararg=vararg, varkwarg=varkwarg,
+                         res=res)
+            state.push(res)
+    else:
+        raise NotImplementedError(PYVERSION)
 
     def _dup_topx(self, state, inst, count):
         orig = [state.pop() for _ in range(count)]
@@ -1187,7 +1330,7 @@ class TraceRunner(object):
         for val in duped:
             state.push(val)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_CALL_INTRINSIC_1(self, state, inst):
             # See https://github.com/python/cpython/blob/v3.12.0rc2/Include/
             # internal/pycore_intrinsics.h#L3-L17C36
@@ -1404,7 +1547,7 @@ class TraceRunner(object):
                      pred=pred)
         state.push(indval)
         end = inst.get_jump_target()
-        if PYVERSION in ((3, 12), ):
+        if PYVERSION in ((3, 12), (3, 13)):
             # Changed in version 3.12: Up until 3.11 the iterator was
             # popped when it was exhausted. Now this is handled using END_FOR
             # op code.
@@ -1490,7 +1633,7 @@ class TraceRunner(object):
     op_BINARY_XOR = _binaryop
 
     def op_MAKE_FUNCTION(self, state, inst, MAKE_CLOSURE=False):
-        if PYVERSION in ((3, 11), (3, 12)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
             # https://github.com/python/cpython/commit/2f180ce
             # name set via co_qualname
             name = None
@@ -1500,14 +1643,19 @@ class TraceRunner(object):
             raise NotImplementedError(PYVERSION)
         code = state.pop()
         closure = annotations = kwdefaults = defaults = None
-        if inst.arg & 0x8:
-            closure = state.pop()
-        if inst.arg & 0x4:
-            annotations = state.pop()
-        if inst.arg & 0x2:
-            kwdefaults = state.pop()
-        if inst.arg & 0x1:
-            defaults = state.pop()
+        if PYVERSION in ((3, 13), ):
+            assert inst.arg is None
+            # SET_FUNCTION_ATTRIBUTE is responsible for setting
+            # closure, annotations, kwdefaults and defaults.
+        else:
+            if inst.arg & 0x8:
+                closure = state.pop()
+            if inst.arg & 0x4:
+                annotations = state.pop()
+            if inst.arg & 0x2:
+                kwdefaults = state.pop()
+            if inst.arg & 0x1:
+                defaults = state.pop()
         res = state.make_temp()
         state.append(
             inst,
@@ -1521,6 +1669,27 @@ class TraceRunner(object):
         )
         state.push(res)
 
+    def op_SET_FUNCTION_ATTRIBUTE(self, state, inst):
+        assert PYVERSION in ((3, 13), )
+        make_func_stack = state.pop()
+        data = state.pop()
+        if inst.arg == 0x1:
+            # 0x01 a tuple of default values for positional-only and
+            #      positional-or-keyword parameters in positional order
+            state.set_function_attribute(make_func_stack, defaults=data)
+        elif inst.arg & 0x2:
+            # 0x02 a tuple of strings containing parameters’ annotations
+            state.set_function_attribute(make_func_stack, kwdefaults=data)
+        elif inst.arg & 0x4:
+            # 0x04 a tuple of strings containing parameters’ annotations
+            state.set_function_attribute(make_func_stack, annotations=data)
+        elif inst.arg == 0x8:
+            # 0x08 a tuple containing cells for free variables, making a closure
+            state.set_function_attribute(make_func_stack, closure=data)
+        else:
+            raise AssertionError("unreachable")
+        state.push(make_func_stack)
+
     def op_MAKE_CLOSURE(self, state, inst):
         self.op_MAKE_FUNCTION(state, inst, MAKE_CLOSURE=True)
 
@@ -1551,7 +1720,7 @@ class TraceRunner(object):
         state.fork(pc=inst.next)
         state.fork(pc=inst.get_jump_target())
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def op_RERAISE(self, state, inst):
             # This isn't handled, but the state is set up anyway
             exc = state.pop()
@@ -1576,7 +1745,7 @@ class TraceRunner(object):
     # NOTE: Please see notes in `interpreter.py` surrounding the implementation
     # of LOAD_METHOD and CALL_METHOD.
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         # LOAD_METHOD has become a pseudo-instruction in 3.12
         pass
     elif PYVERSION in ((3, 11), ):
@@ -1828,9 +1997,14 @@ class _State(object):
         return self.get_top_block('TRY') is not None
 
     def get_varname(self, inst):
+        """Get referenced variable name from the instruction's oparg
+        """
+        return self.get_varname_by_arg(inst.arg)
+
+    def get_varname_by_arg(self, oparg: int):
         """Get referenced variable name from the oparg
         """
-        return self._bytecode.co_varnames[inst.arg]
+        return self._bytecode.co_varnames[oparg]
 
     def terminate(self):
         """Mark block as terminated
@@ -1852,7 +2026,7 @@ class _State(object):
                 stack.append(self.make_temp())
         # Handle changes on the blockstack
         blockstack = list(self._blockstack)
-        if PYVERSION in ((3, 11), (3, 12)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
             # pop expired block in destination pc
             while blockstack:
                 top = blockstack[-1]
@@ -1940,7 +2114,21 @@ class StatePy311(_State):
         return self.make_temp(prefix="null$")
 
 
-if PYVERSION >= (3, 11):
+class StatePy313(StatePy311):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._make_func_attrs = defaultdict(dict)
+
+    def set_function_attribute(self, make_func_res, **kwargs):
+        self._make_func_attrs[make_func_res].update(kwargs)
+
+    def get_function_attributes(self, make_func_res):
+        return self._make_func_attrs[make_func_res]
+
+
+if PYVERSION in ((3, 13), ):
+    State = StatePy313
+elif PYVERSION in ((3, 11), (3, 12)):
     State = StatePy311
 elif PYVERSION < (3, 11):
     State = _State
@@ -1970,8 +2158,20 @@ AdaptBlockInfo = namedtuple(
 
 
 def adapt_state_infos(state):
+    def process_function_attributes(inst_pair):
+        offset, data = inst_pair
+        inst = state._bytecode[offset]
+        if inst.opname == "MAKE_FUNCTION":
+            data.update(state.get_function_attributes(data['res']))
+        return offset, data
+    if PYVERSION in ((3, 13), ):
+        insts = tuple(map(process_function_attributes, state.instructions))
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        insts = tuple(state.instructions)
+    else:
+        raise NotImplementedError(PYVERSION)
     return AdaptBlockInfo(
-        insts=tuple(state.instructions),
+        insts=insts,
         outgoing_phis=state.outgoing_phis,
         blockstack=state.blockstack_initial,
         active_try_block=state.find_initial_try_block(),
Index: numba-0.60.0/numba/core/controlflow.py
===================================================================
--- numba-0.60.0.orig/numba/core/controlflow.py
+++ numba-0.60.0/numba/core/controlflow.py
@@ -954,7 +954,7 @@ class ControlFlowAnalysis(object):
         self._curblock.terminating = True
         self._force_new_block = True
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_RETURN_CONST(self, inst):
             self._curblock.terminating = True
             self._force_new_block = True
Index: numba-0.60.0/numba/core/interpreter.py
===================================================================
--- numba-0.60.0.orig/numba/core/interpreter.py
+++ numba-0.60.0/numba/core/interpreter.py
@@ -6,7 +6,11 @@ import logging
 import textwrap
 
 from numba.core import errors, ir, config
-from numba.core.errors import NotDefinedError, UnsupportedError, error_extras
+from numba.core.errors import (
+    NotDefinedError,
+    UnsupportedBytecodeError,
+    error_extras,
+)
 from numba.core.ir_utils import get_definition, guard
 from numba.core.utils import (PYVERSION, BINOPS_TO_OPERATORS,
                               INPLACE_BINOPS_TO_OPERATORS,)
@@ -15,7 +19,7 @@ from numba.core.unsafe import eh
 from numba.cpython.unsafe.tuple import unpack_single_tuple
 
 
-if PYVERSION in ((3, 12), ):
+if PYVERSION in ((3, 12), (3, 13)):
     # Operands for CALL_INTRINSIC_1
     from numba.core.byteflow import CALL_INTRINSIC_1_Operand as ci1op
 elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -108,7 +112,7 @@ def _remove_assignment_definition(old_bo
         func_ir._definitions[lhs].remove(rhs)
         already_deleted_defs[lhs].add(rhs)
     elif rhs not in already_deleted_defs[lhs]:
-        raise UnsupportedError(
+        raise UnsupportedBytecodeError(
             "Inconsistency found in the definitions while executing"
             " a peephole optimization. This suggests an internal"
             " error or inconsistency elsewhere in the compiler."
@@ -211,7 +215,7 @@ def _call_function_ex_replace_kws_large(
         ):
             # We cannot handle this format so raise the
             # original error message.
-            raise UnsupportedError(errmsg)
+            raise UnsupportedBytecodeError(errmsg)
         key_var_name = const_stmt.target.name
         key_val = const_stmt.value.value
         search_start += 1
@@ -257,7 +261,7 @@ def _call_function_ex_replace_kws_large(
         ):
             # We cannot handle this format so raise the
             # original error message.
-            raise UnsupportedError(errmsg)
+            raise UnsupportedBytecodeError(errmsg)
         setitem_stmt = old_body[search_start + 1]
         if not (
             isinstance(setitem_stmt, ir.Assign)
@@ -277,7 +281,7 @@ def _call_function_ex_replace_kws_large(
             # getattr. If for some reason this doesn't match the code
             # format, we raise the original error message. This check
             # is meant as a precaution.
-            raise UnsupportedError(errmsg)
+            raise UnsupportedBytecodeError(errmsg)
         arg_var = setitem_stmt.value.args[1]
         # Append the (key, value) pair.
         kws.append((key_val, arg_var))
@@ -421,7 +425,7 @@ def _call_function_ex_replace_args_large
                 and concat_stmt.value.fn == operator.add
             ):
                 # We cannot handle this format.
-                raise UnsupportedError(errmsg)
+                raise UnsupportedBytecodeError(errmsg)
             lhs_name = concat_stmt.value.lhs.name
             rhs_name = concat_stmt.value.rhs.name
             # The previous statement should be a
@@ -439,7 +443,7 @@ def _call_function_ex_replace_args_large
                 and len(arg_tuple_stmt.value.items) == 1
             ):
                 # We cannot handle this format.
-                raise UnsupportedError(errmsg)
+                raise UnsupportedBytecodeError(errmsg)
             if arg_tuple_stmt.target.name == lhs_name:
                 # The tuple should always be generated on the RHS.
                 raise AssertionError("unreachable")
@@ -447,7 +451,7 @@ def _call_function_ex_replace_args_large
                 target_name = lhs_name
             else:
                 # We cannot handle this format.
-                raise UnsupportedError(errmsg)
+                raise UnsupportedBytecodeError(errmsg)
             total_args.append(
                 arg_tuple_stmt.value.items[0]
             )
@@ -497,7 +501,7 @@ def _call_function_ex_replace_args_large
         # If we reached the start we never found the build_tuple.
         # We cannot handle this format so raise the
         # original error message.
-        raise UnsupportedError(errmsg)
+        raise UnsupportedBytecodeError(errmsg)
     # Reverse the arguments so we get the correct order.
     return total_args[::-1]
 
@@ -586,7 +590,7 @@ def peep_hole_call_function_ex_to_call_f
                     # If we couldn't find where the kwargs are created
                     # then it should be a normal **kwargs call
                     # so we produce an unsupported message.
-                    raise UnsupportedError(errmsg)
+                    raise UnsupportedBytecodeError(errmsg)
                 # Determine the kws
                 if keyword_def.value.items:
                     # n_kws <= 15 case.
@@ -638,7 +642,7 @@ def peep_hole_call_function_ex_to_call_f
                     if args:
                         # If we have vararg then args is expected to
                         # be an empty list.
-                        raise UnsupportedError(errmsg)
+                        raise UnsupportedBytecodeError(errmsg)
                     vararg_loc = start_search
                     args_def = None
                     found = False
@@ -654,7 +658,7 @@ def peep_hole_call_function_ex_to_call_f
                     if not found:
                         # If we couldn't find where the args are created
                         # then we can't handle this format.
-                        raise UnsupportedError(errmsg)
+                        raise UnsupportedBytecodeError(errmsg)
                     if (
                         isinstance(args_def.value, ir.Expr)
                         and args_def.value.op == "build_tuple"
@@ -683,7 +687,7 @@ def peep_hole_call_function_ex_to_call_f
                         # If there is a call with vararg we need to check
                         # if the list -> tuple conversion failed and if so
                         # throw an error.
-                        raise UnsupportedError(errmsg)
+                        raise UnsupportedBytecodeError(errmsg)
                     else:
                         # Here the IR is an initial empty build_tuple.
                         # Then for each arg, a new tuple with a single
@@ -747,7 +751,7 @@ def peep_hole_call_function_ex_to_call_f
                     # exception.
                     expr = func_ir._definitions[vararg_name][0]
                     if isinstance(expr, ir.Expr) and expr.op == "list_to_tuple":
-                        raise UnsupportedError(errmsg)
+                        raise UnsupportedBytecodeError(errmsg)
 
             new_body.append(stmt)
         # Replace the block body if we changed the IR
@@ -1197,7 +1201,7 @@ def peep_hole_fuse_dict_add_updates(func
                             else:
                                 # If we cannot remove _update_from_bytecode
                                 # Then raise an error for the user.
-                                raise UnsupportedError(errmsg)
+                                raise UnsupportedBytecodeError(errmsg)
 
             # Check if we need to drop any maps from being tracked.
             # Skip the setitem/_update_from_bytecode getattr that
@@ -1385,7 +1389,7 @@ class Interpreter(object):
                                          max(inst_blocks.body))
         self.last_active_offset = last_active_offset
 
-        if PYVERSION in ((3, 12), ):
+        if PYVERSION in ((3, 12), (3, 13)):
             self.active_exception_entries = tuple(
                 [entry for entry in self.bytecode.exception_entries
                  if entry.start < self.last_active_offset])
@@ -1401,7 +1405,7 @@ class Interpreter(object):
         # Interpret loop
         for inst, kws in self._iter_inst():
             self._dispatch(inst, kws)
-        if PYVERSION in ((3, 11), (3, 12)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
             # Insert end of try markers
             self._end_try_blocks()
         elif PYVERSION in ((3, 9), (3, 10)):
@@ -1418,12 +1422,12 @@ class Interpreter(object):
         # post process the IR to rewrite opcodes/byte sequences that are too
         # involved to risk handling as part of direct interpretation
         peepholes = []
-        if PYVERSION in ((3, 11), (3, 12)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
             peepholes.append(peep_hole_split_at_pop_block)
-        if PYVERSION in ((3, 9), (3, 10), (3, 11), (3, 12)):
+        if PYVERSION in ((3, 9), (3, 10), (3, 11), (3, 12), (3, 13)):
             peepholes.append(peep_hole_list_to_tuple)
         peepholes.append(peep_hole_delete_with_exit)
-        if PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
             # peep_hole_call_function_ex_to_call_function_kw
             # depends on peep_hole_list_to_tuple converting
             # any large number of arguments from a list to a
@@ -1456,7 +1460,7 @@ class Interpreter(object):
 
         See also: _insert_try_block_end
         """
-        assert PYVERSION in ((3, 11), (3, 12))
+        assert PYVERSION in ((3, 11), (3, 12), (3, 13))
         graph = self.cfa.graph
         for offset, block in self.blocks.items():
             # Get current blockstack
@@ -1507,7 +1511,7 @@ class Interpreter(object):
             first = uservar[0]
             loc = self.current_scope.get(first).loc
             msg = "Exception object cannot be stored into variable ({})."
-            raise errors.UnsupportedError(msg.format(first), loc=loc)
+            raise errors.UnsupportedBytecodeError(msg.format(first), loc=loc)
 
     def init_first_block(self):
         # Define variables receiving the function arguments
@@ -1564,7 +1568,7 @@ class Interpreter(object):
         self.dfainfo = self.dfa.infos[self.current_block_offset]
         self.assigner = Assigner()
         # Check out-of-scope syntactic-block
-        if PYVERSION in ((3, 11), (3, 12)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
             # This is recreating pre-3.11 code structure
             while self.syntax_blocks:
                 if offset >= self.syntax_blocks[-1].exit:
@@ -1735,7 +1739,7 @@ class Interpreter(object):
                 val = self.get(varname)
             except ir.NotDefinedError:
                 # Hack to make sure exception variables are defined
-                assert PYVERSION in ((3, 11), (3, 12)), \
+                assert PYVERSION in ((3, 11), (3, 12), (3, 13)), \
                        "unexpected missing definition"
                 val = ir.Const(value=None, loc=self.loc)
             stmt = ir.Assign(value=val, target=target,
@@ -1795,7 +1799,7 @@ class Interpreter(object):
         if self._DEBUG_PRINT:
             print(inst)
         assert self.current_block is not None
-        if PYVERSION in ((3, 11), (3, 12)):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13)):
             if self.syntax_blocks:
                 top = self.syntax_blocks[-1]
                 if isinstance(top, ir.With) :
@@ -1825,6 +1829,9 @@ class Interpreter(object):
                 if not config.FULL_TRACEBACKS:
                     raise err from None
                 else:
+                    m = f"handling op: {inst} | offset: {inst.offset}"
+                    err.add_context(m)
+                    err.add_context(self.bytecode.dump())
                     raise err
 
     # --- Scope operations ---
@@ -1921,6 +1928,10 @@ class Interpreter(object):
                                           loc=self.loc)
             self.store(expr, st)
 
+    def op_FORMAT_SIMPLE(self, inst, value, res, strvar):
+        # Same as FORMAT_VALUE
+        return self.op_FORMAT_VALUE(inst, value, res, strvar)
+
     def op_FORMAT_VALUE(self, inst, value, res, strvar):
         """
         FORMAT_VALUE(flags): flags argument specifies format spec which is not
@@ -1971,7 +1982,7 @@ class Interpreter(object):
                                      (), loc=self.loc)
         self.store(value=sliceinst, name=res)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_BINARY_SLICE(self, inst, start, end, container, res, slicevar,
                             temp_res):
             start = self.get(start)
@@ -1990,7 +2001,7 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_STORE_SLICE(self, inst, start, end, container, value, res,
                            slicevar):
             start = self.get(start)
@@ -2218,11 +2229,58 @@ class Interpreter(object):
         stmt = ir.DelItem(base, self.get(indexvar), loc=self.loc)
         self.current_block.append(stmt)
 
-    def op_LOAD_FAST(self, inst, res):
+    def _op_LOAD_FAST(self, inst, res):
         srcname = self.code_locals[inst.arg]
         self.store(value=self.get(srcname), name=res)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 13), ):
+        def op_LOAD_FAST(self, inst, res, as_load_deref=False):
+            if as_load_deref:
+                self.op_LOAD_DEREF(inst, res)
+            else:
+                self._op_LOAD_FAST(inst, res)
+
+    else:
+        op_LOAD_FAST = _op_LOAD_FAST
+
+    if PYVERSION in ((3, 13),):
+        def op_LOAD_FAST_LOAD_FAST(self, inst, res1, res2):
+            oparg = inst.arg
+            oparg1 = oparg >> 4
+            oparg2 = oparg & 15
+            src1 = self.get(self.code_locals[oparg1])
+            src2 = self.get(self.code_locals[oparg2])
+            self.store(value=src1, name=res1)
+            self.store(value=src2, name=res2)
+
+        def op_STORE_FAST_LOAD_FAST(self, inst, store_value, load_res):
+            oparg = inst.arg
+            oparg1 = oparg >> 4
+            oparg2 = oparg & 15
+
+            dstname = self.code_locals[oparg1]
+            dst_value = self.get(store_value)
+            self.store(value=dst_value, name=dstname)
+
+            src_value = self.get(self.code_locals[oparg2])
+            self.store(value=src_value, name=load_res)
+
+        def op_STORE_FAST_STORE_FAST(self, inst, value1, value2):
+            oparg = inst.arg
+            oparg1 = oparg >> 4
+            oparg2 = oparg & 15
+
+            dstname = self.code_locals[oparg1]
+            self.store(value=self.get(value1), name=dstname)
+            dstname = self.code_locals[oparg2]
+            self.store(value=self.get(value2), name=dstname)
+
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
+    if PYVERSION in ((3, 12), (3, 13)):
         op_LOAD_FAST_CHECK = op_LOAD_FAST
 
         def op_LOAD_FAST_AND_CLEAR(self, inst, res):
@@ -2269,7 +2327,7 @@ class Interpreter(object):
 
     def op_LOAD_ATTR(self, inst, item, res):
         item = self.get(item)
-        if PYVERSION in ((3, 12), ):
+        if PYVERSION in ((3, 12), (3, 13)):
             attr = self.code_names[inst.arg >> 1]
         elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
             attr = self.code_names[inst.arg]
@@ -2300,7 +2358,7 @@ class Interpreter(object):
             const = ir.Const(value, loc=self.loc)
         self.store(const, res)
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def op_LOAD_GLOBAL(self, inst, idx, res):
             name = self.code_names[idx]
             value = self.get_global_value(name)
@@ -2318,11 +2376,15 @@ class Interpreter(object):
     def op_COPY_FREE_VARS(self, inst):
         pass
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def op_LOAD_DEREF(self, inst, res):
             name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
             if name in self.code_cellvars:
-                gl = self.get(name)
+                try:
+                    gl = self.get(name)
+                except NotDefinedError:
+                    msg = "Unsupported use of cell variable encountered"
+                    raise NotImplementedError(msg)
             elif name in self.code_freevars:
                 idx = self.code_freevars.index(name)
                 value = self.get_closure_value(idx)
@@ -2343,11 +2405,11 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def op_MAKE_CELL(self, inst):
             pass  # ignored bytecode
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def op_STORE_DEREF(self, inst, value):
             name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
             value = self.get(value)
@@ -2387,7 +2449,7 @@ class Interpreter(object):
 
     def op_BEFORE_WITH(self, inst, contextmanager, exitfn, end):
         assert self.blocks[inst.offset] is self.current_block
-        if PYVERSION in ((3, 12), ):
+        if PYVERSION in ((3, 12), (3, 13)):
             # Python 3.12 hack for handling nested with blocks
             if end > self.last_active_offset:
                 # Use exception entries to figure out end of syntax block
@@ -2437,6 +2499,7 @@ class Interpreter(object):
         func = self.get(func)
         args = [self.get(x) for x in args]
         if kw_names is not None:
+            assert PYVERSION < (3, 13)
             names = self.code_consts[kw_names]
             kwargs = list(zip(names, args[-len(names):]))
             args = args[:-len(names)]
@@ -2445,6 +2508,19 @@ class Interpreter(object):
         expr = ir.Expr.call(func, args, kwargs, loc=self.loc)
         self.store(expr, res)
 
+    if PYVERSION in ((3, 13),):
+        def op_CALL_KW(self, inst, func, args, kw_names, res):
+            func = self.get(func)
+            args = [self.get(x) for x in args]
+            consti = int(kw_names.rsplit('.', 2)[-1])
+            names = self.code_consts[consti]
+            kwargs = list(zip(names, args[-len(names):]))
+            args = args[:-len(names)]
+            expr = ir.Expr.call(func, args, kwargs, loc=self.loc)
+            self.store(expr, res)
+    else:
+        assert PYVERSION < (3, 13)
+
     def op_CALL_FUNCTION(self, inst, func, args, res):
         func = self.get(func)
         args = [self.get(x) for x in args]
@@ -2878,6 +2954,8 @@ class Interpreter(object):
         jmp = ir.Jump(inst.get_jump_target(), loc=self.loc)
         self.current_block.append(jmp)
 
+    op_JUMP_BACKWARD_NO_INTERRUPT = op_JUMP_BACKWARD
+
     def op_POP_BLOCK(self, inst, kind=None):
         if kind is None:
             self.syntax_blocks.pop()
@@ -2892,7 +2970,7 @@ class Interpreter(object):
         ret = ir.Return(self.get(castval), loc=self.loc)
         self.current_block.append(ret)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_RETURN_CONST(self, inst, retval, castval):
             value = self.code_consts[inst.arg]
             const = ir.Const(value, loc=self.loc)
@@ -2905,8 +2983,20 @@ class Interpreter(object):
     else:
         raise NotImplementedError(PYVERSION)
 
+    if PYVERSION in ((3, 13),):
+        def op_TO_BOOL(self, inst, val, res):
+            self.store(self.get(val), res) # TODO: just a lazy hack
+
+    elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        pass
+    else:
+        raise NotImplementedError(PYVERSION)
+
     def op_COMPARE_OP(self, inst, lhs, rhs, res):
-        if PYVERSION in ((3, 12), ):
+        if PYVERSION in ((3, 13),):
+            op = dis.cmp_op[inst.arg >> 5]
+            # TODO: fifth lowest bit now indicates a forced version to bool.
+        elif PYVERSION in ((3, 12),):
             op = dis.cmp_op[inst.arg >> 4]
         elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
             op = dis.cmp_op[inst.arg]
@@ -3024,7 +3114,7 @@ class Interpreter(object):
     def op_POP_JUMP_FORWARD_IF_NOT_NONE(self, inst, pred):
         self._jump_if_none(inst, pred, False)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_POP_JUMP_IF_NONE(self, inst, pred):
             self._jump_if_none(inst, pred, True)
 
@@ -3152,7 +3242,7 @@ class Interpreter(object):
                 "Probably caused by complex control-flow constructs; "
                 "e.g. try-except"
             )
-            raise errors.UnsupportedError(msg, loc=self.loc)
+            raise errors.UnsupportedBytecodeError(msg, loc=self.loc)
         fcode = assume_code_const.value
         if name:
             name = self.get(name)
@@ -3166,14 +3256,14 @@ class Interpreter(object):
         self.op_MAKE_FUNCTION(inst, name, code, closure, annotations,
                               kwdefaults, defaults, res)
 
-    if PYVERSION in ((3, 11), (3, 12)):
+    if PYVERSION in ((3, 11), (3, 12), (3, 13)):
         def op_LOAD_CLOSURE(self, inst, res):
             name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
             if name in self.code_cellvars:
                 try:
                     gl = self.get(name)
                 except NotDefinedError:
-                    msg = "Unsupported use of op_LOAD_CLOSURE encountered"
+                    msg = "Unsupported use of cell variable encountered"
                     raise NotImplementedError(msg)
             elif name in self.code_freevars:
                 idx = self.code_freevars.index(name)
@@ -3191,7 +3281,7 @@ class Interpreter(object):
                 try:
                     gl = self.get(name)
                 except NotDefinedError:
-                    msg = "Unsupported use of op_LOAD_CLOSURE encountered"
+                    msg = "Unsupported use of cell variable encountered"
                     raise NotImplementedError(msg)
             else:
                 idx = inst.arg - n_cellvars
@@ -3228,7 +3318,7 @@ class Interpreter(object):
                "op_LIST_EXTEND at the start of a block.\n\nThis could be "
                "due to the use of a branch in a tuple unpacking statement.")
         if not self.current_block.body:
-            raise errors.UnsupportedError(msg)
+            raise errors.UnsupportedBytecodeError(msg)
 
         # is last emitted statement a build_tuple?
         stmt = self.current_block.body[-1]
@@ -3258,7 +3348,7 @@ class Interpreter(object):
                     ok = False
                     break
         if ok and build_empty_list is None:
-            raise errors.UnsupportedError(msg)
+            raise errors.UnsupportedBytecodeError(msg)
         if ok:
             stmts = self.current_block.body
             build_tuple_asgn = self.current_block.body[-1]
@@ -3304,7 +3394,7 @@ class Interpreter(object):
     def op_CALL_METHOD(self, *args, **kws):
         self.op_CALL_FUNCTION(*args, **kws)
 
-    if PYVERSION in ((3, 12), ):
+    if PYVERSION in ((3, 12), (3, 13)):
         def op_CALL_INTRINSIC_1(self, inst, operand, **kwargs):
             if operand == ci1op.INTRINSIC_STOPITERATION_ERROR:
                 stmt = ir.StaticRaise(INTRINSIC_STOPITERATION_ERROR, (),
@@ -3325,7 +3415,7 @@ class Interpreter(object):
         raise NotImplementedError(PYVERSION)
 
 
-if PYVERSION in ((3, 12), ):
+if PYVERSION in ((3, 12), (3, 13)):
     class INTRINSIC_STOPITERATION_ERROR(AssertionError):
         pass
 elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
Index: numba-0.60.0/numba/cpython/unicode.py
===================================================================
--- numba-0.60.0.orig/numba/cpython/unicode.py
+++ numba-0.60.0/numba/cpython/unicode.py
@@ -349,7 +349,7 @@ def _set_code_point(a, i, ch):
             "Unexpected unicode representation in _set_code_point")
 
 
-if PYVERSION in ((3, 12),):
+if PYVERSION in ((3, 12), (3, 13)):
     @register_jitable
     def _pick_kind(kind1, kind2):
         if kind1 == PY_UNICODE_1BYTE_KIND:
@@ -393,7 +393,7 @@ def _pick_ascii(is_ascii1, is_ascii2):
     return types.uint32(0)
 
 
-if PYVERSION in ((3, 12),):
+if PYVERSION in ((3, 12), (3, 13)):
     @register_jitable
     def _kind_to_byte_width(kind):
         if kind == PY_UNICODE_1BYTE_KIND:
@@ -2047,7 +2047,7 @@ def _is_upper(is_lower, is_upper, is_tit
     def impl(a):
         l = len(a)
         if l == 1:
-            return is_upper(_get_code_point(a, 0))
+            return is_upper(_get_code_point(a, 0)) != 0
         if l == 0:
             return False
         cased = False
Index: numba-0.60.0/numba/experimental/jitclass/base.py
===================================================================
--- numba-0.60.0.orig/numba/experimental/jitclass/base.py
+++ numba-0.60.0/numba/experimental/jitclass/base.py
@@ -282,6 +282,9 @@ def _drop_ignored_attrs(dct):
     drop = set(['__weakref__',
                 '__module__',
                 '__dict__'])
+    if utils.PYVERSION == (3, 13):
+        # new in python 3.13
+        drop |= set(['__firstlineno__', '__static_attributes__'])
 
     if '__annotations__' in dct:
         drop.add('__annotations__')
@@ -300,7 +303,7 @@ def _drop_ignored_attrs(dct):
         drop.add('__hash__')
 
     for k in drop:
-        del dct[k]
+        dct.pop(k)
 
 
 class ClassBuilder(object):
Index: numba-0.60.0/numba/core/compiler.py
===================================================================
--- numba-0.60.0.orig/numba/core/compiler.py
+++ numba-0.60.0/numba/core/compiler.py
@@ -476,10 +476,7 @@ class CompilerBase(object):
                     res = e.result
                     break
                 except Exception as e:
-                    if (utils.use_new_style_errors() and not
-                            isinstance(e, errors.NumbaError)):
-                        raise e
-
+                    utils.handle_new_style_errors(e)
                     self.state.status.fail_reason = e
                     if is_final_pipeline:
                         raise e
Index: numba-0.60.0/numba/core/compiler_machinery.py
===================================================================
--- numba-0.60.0.orig/numba/core/compiler_machinery.py
+++ numba-0.60.0/numba/core/compiler_machinery.py
@@ -304,7 +304,8 @@ class PassManager(object):
             args=str(internal_state.args),
             return_type=str(internal_state.return_type),
         )
-        with ev.trigger_event("numba:run_pass", data=ev_details):
+        errctx = errors.new_error_context(f"Pass {pss.name()}")
+        with ev.trigger_event("numba:run_pass", data=ev_details), errctx:
             with SimpleTimer() as init_time:
                 mutated |= check(pss.run_initialization, internal_state)
             with SimpleTimer() as pass_time:
@@ -359,9 +360,7 @@ class PassManager(object):
             except _EarlyPipelineCompletion as e:
                 raise e
             except Exception as e:
-                if (utils.use_new_style_errors() and not
-                        isinstance(e, errors.NumbaError)):
-                    raise e
+                utils.handle_new_style_errors(e)
                 msg = "Failed in %s mode pipeline (step: %s)" % \
                     (self.pipeline_name, pass_desc)
                 patched_exception = self._patch_error(msg, e)
Index: numba-0.60.0/numba/core/errors.py
===================================================================
--- numba-0.60.0.orig/numba/core/errors.py
+++ numba-0.60.0/numba/core/errors.py
@@ -532,7 +532,6 @@ class WarningsFixer(object):
 
 
 class NumbaError(Exception):
-
     def __init__(self, msg, loc=None, highlighting=True):
         self.msg = msg
         self.loc = loc
@@ -578,7 +577,13 @@ class UnsupportedError(NumbaError):
     """
     Numba does not have an implementation for this functionality.
     """
-    pass
+
+
+class UnsupportedBytecodeError(Exception):
+    """Unsupported bytecode is non-recoverable
+    """
+    def __init__(self, msg, loc=None):
+        super().__init__(f"{msg}. Raised from {loc}")
 
 
 class UnsupportedRewriteError(UnsupportedError):
Index: numba-0.60.0/numba/core/types/functions.py
===================================================================
--- numba-0.60.0.orig/numba/core/types/functions.py
+++ numba-0.60.0/numba/core/types/functions.py
@@ -307,12 +307,9 @@ class BaseFunction(Callable):
                                     for k, v in kws.items()}
                         sig = temp.apply(nolitargs, nolitkws)
                 except Exception as e:
-                    if (utils.use_new_style_errors() and not
-                            isinstance(e, errors.NumbaError)):
-                        raise e
-                    else:
-                        sig = None
-                        failures.add_error(temp, False, e, uselit)
+                    utils.handle_new_style_errors(e)
+                    sig = None
+                    failures.add_error(temp, False, e, uselit)
                 else:
                     if sig is not None:
                         self._impl_keys[sig.args] = temp.get_impl_key(sig)
Index: numba-0.60.0/numba/core/utils.py
===================================================================
--- numba-0.60.0.orig/numba/core/utils.py
+++ numba-0.60.0/numba/core/utils.py
@@ -230,6 +230,17 @@ def use_old_style_errors():
     return res
 
 
+def handle_new_style_errors(e):
+    """Handle new_style error by raising the exception immediately if they are
+    non-recoverable.
+    """
+    from numba.core import errors
+
+    if use_new_style_errors():
+        if not isinstance(e, errors.NumbaError):
+            raise e
+
+
 class ThreadLocalStack:
     """A TLS stack container.
 
Index: numba-0.60.0/numba/stencils/stencil.py
===================================================================
--- numba-0.60.0.orig/numba/stencils/stencil.py
+++ numba-0.60.0/numba/stencils/stencil.py
@@ -402,8 +402,9 @@ class StencilFunc(object):
         sig = signature(real_ret, *argtys_extra)
         dummy_text = ("def __numba_dummy_stencil({}{}):\n    pass\n".format(
                         ",".join(self.kernel_ir.arg_names), sig_extra))
-        exec(dummy_text) in globals(), locals()
-        dummy_func = eval("__numba_dummy_stencil")
+        dct = {}
+        exec(dummy_text, dct)
+        dummy_func = dct["__numba_dummy_stencil"]
         sig = sig.replace(pysig=utils.pysignature(dummy_func))
         self._targetctx.insert_func_defn([(self._lower_me, self, argtys_extra)])
         self._type_cache[argtys_extra] = (sig, result, typemap, calltypes)
@@ -659,8 +660,10 @@ class StencilFunc(object):
             print(func_text)
 
         # Force the new stencil function into existence.
-        exec(func_text) in globals(), locals()
-        stencil_func = eval(stencil_func_name)
+        dct = {}
+        dct.update(globals())
+        exec(func_text, dct)
+        stencil_func = dct[stencil_func_name]
         if sigret is not None:
             pysig = utils.pysignature(stencil_func)
             sigret.pysig = pysig
Index: numba-0.60.0/numba/tests/test_debug.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_debug.py
+++ numba-0.60.0/numba/tests/test_debug.py
@@ -73,7 +73,7 @@ class DebugTestBase(TestCase):
                 self.assert_fails(check_meth, out)
 
     def _check_dump_bytecode(self, out):
-        if utils.PYVERSION in ((3, 11), (3, 12)):
+        if utils.PYVERSION in ((3, 11), (3, 12), (3, 13)):
             self.assertIn('BINARY_OP', out)
         elif utils.PYVERSION in ((3, 9), (3, 10)):
             self.assertIn('BINARY_ADD', out)
Index: numba-0.60.0/numba/tests/test_ir_inlining.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_ir_inlining.py
+++ numba-0.60.0/numba/tests/test_ir_inlining.py
@@ -444,7 +444,7 @@ class TestFunctionInlining(MemoryLeakMix
             return bar(z + 2)
 
         # block count changes with Python version due to bytecode differences.
-        if utils.PYVERSION in ((3, 12), ):
+        if utils.PYVERSION in ((3, 12), (3, 13)):
             bc = 39
         elif utils.PYVERSION in ((3, 10), (3, 11)):
             bc = 35
Index: numba-0.60.0/numba/tests/test_closure.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_closure.py
+++ numba-0.60.0/numba/tests/test_closure.py
@@ -400,13 +400,13 @@ class TestInlinedClosure(TestCase):
         with self.assertRaises(NotImplementedError) as raises:
             cfunc = jit(nopython=True)(outer3)
             cfunc(var)
-        msg = "Unsupported use of op_LOAD_CLOSURE encountered"
+        msg = "Unsupported use of cell variable encountered"
         self.assertIn(msg, str(raises.exception))
 
         with self.assertRaises(NotImplementedError) as raises:
             cfunc = jit(nopython=True)(outer4)
             cfunc(var)
-        msg = "Unsupported use of op_LOAD_CLOSURE encountered"
+        msg = "Unsupported use of cell variable encountered"
         self.assertIn(msg, str(raises.exception))
 
         with self.assertRaises(TypingError) as raises:
Index: numba-0.60.0/numba/core/inline_closurecall.py
===================================================================
--- numba-0.60.0.orig/numba/core/inline_closurecall.py
+++ numba-0.60.0/numba/core/inline_closurecall.py
@@ -95,7 +95,7 @@ class InlineClosureCallPass(object):
         modified = False
         work_list = list(self.func_ir.blocks.items())
         debug_print = _make_debug_print("InlineClosureCallPass")
-        debug_print("START")
+        debug_print(f"START {self.func_ir.func_id.func_qualname}")
         while work_list:
             _label, block = work_list.pop()
             for i, instr in enumerate(block.body):
Index: numba-0.60.0/numba/pycc/modulemixin.c
===================================================================
--- numba-0.60.0.orig/numba/pycc/modulemixin.c
+++ numba-0.60.0/numba/pycc/modulemixin.c
@@ -23,6 +23,12 @@
 #include "../core/runtime/nrt.h"
 #endif
 
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION >= 12)
+    #define Py_BUILD_CORE 1
+    #include "internal/pycore_pyhash.h"
+    #undef Py_BUILD_CORE
+#endif
+
 /* Defines hashsecret variables (see issue #6386) */
 int64_t _numba_hashsecret_siphash_k0;
 int64_t _numba_hashsecret_siphash_k1;
Index: numba-0.60.0/numba/tests/test_operators.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_operators.py
+++ numba-0.60.0/numba/tests/test_operators.py
@@ -768,7 +768,7 @@ class TestOperators(TestCase):
         # error message depends on Python version.
         if utils.PYVERSION in ((3, 9),):
             msg = "can't mod complex numbers"
-        elif utils.PYVERSION in ((3, 10), (3, 11), (3, 12)):
+        elif utils.PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
             msg = "unsupported operand type(s) for %"
         else:
             raise NotImplementedError(utils.PYVERSION)
Index: numba-0.60.0/numba/tests/test_parfors.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_parfors.py
+++ numba-0.60.0/numba/tests/test_parfors.py
@@ -3550,7 +3550,7 @@ class TestPrangeBase(TestParforsBase):
             prange_names.append('prange')
             prange_names = tuple(prange_names)
             prange_idx = len(prange_names) - 1
-            if utils.PYVERSION in ((3, 11), (3, 12)):
+            if utils.PYVERSION in ((3, 11), (3, 12), (3, 13)):
                 # this is the inverse of _fix_LOAD_GLOBAL_arg
                 prange_idx = 1 + (prange_idx << 1)
             elif utils.PYVERSION in ((3, 9), (3, 10)):
Index: numba-0.60.0/numba/tests/support.py
===================================================================
--- numba-0.60.0.orig/numba/tests/support.py
+++ numba-0.60.0/numba/tests/support.py
@@ -128,6 +128,12 @@ def expected_failure_np2(fn):
     else:
         return fn
 
+def expected_failure_py313(fn):
+    if utils.PYVERSION == (3, 13):
+        return unittest.expectedFailure(fn)
+    else:
+        return fn
+
 _msg = "SciPy needed for test"
 skip_unless_scipy = unittest.skipIf(scipy is None, _msg)
 
Index: numba-0.60.0/numba/tests/test_np_functions.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_np_functions.py
+++ numba-0.60.0/numba/tests/test_np_functions.py
@@ -6192,8 +6192,9 @@ def foo():
         tystr = ty.__name__
         basestr = basefunc.__name__
         funcstr = self.template % (tystr, basestr)
-        eval(compile(funcstr, '<string>', 'exec'))
-        return locals()['foo']
+        dct = {}
+        exec(compile(funcstr, '<string>', 'exec'), globals(), dct)
+        return dct['foo']
 
     @unittest.skipIf(numpy_version >= (1, 24), "NumPy < 1.24 required")
     def test_MachAr(self):
Index: numba-0.60.0/numba/tests/test_unicode.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_unicode.py
+++ numba-0.60.0/numba/tests/test_unicode.py
@@ -6,10 +6,12 @@ from numba import njit, typeof
 from numba.core import types
 import unittest
 from numba.tests.support import (TestCase, no_pyobj_flags, MemoryLeakMixin)
-from numba.core.errors import TypingError, UnsupportedError
+from numba.core.errors import (TypingError, UnsupportedError,
+                               UnsupportedBytecodeError)
 from numba.cpython.unicode import _MAX_UNICODE
 from numba.core.types.functions import _header_lead
 from numba.extending import overload
+from numba.core.utils import PYVERSION
 
 
 def isascii(s):
@@ -2697,10 +2699,17 @@ class TestUnicodeAuxillary(BaseTest):
         self.assertEqual(got, expected)
 
         # check error when format spec provided
-        with self.assertRaises(UnsupportedError) as raises:
+        unsupported_errors = (UnsupportedError, UnsupportedBytecodeError)
+        with self.assertRaises(unsupported_errors) as raises:
             njit(impl4)(["A", "B"])
-        msg = "format spec in f-strings not supported yet"
-        self.assertIn(msg, str(raises.exception))
+        if PYVERSION in ((3, 13),):
+            msg = "Use of unsupported opcode (FORMAT_WITH_SPEC)"
+            self.assertIn(msg, str(raises.exception))
+        elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+            msg = "format spec in f-strings not supported yet"
+            self.assertIn(msg, str(raises.exception))
+        else:
+            raise NotImplementedError(PYVERSION)
         self.assertEqual(impl5(), njit(impl5)())
 
 
Index: numba-0.60.0/numba/core/ir.py
===================================================================
--- numba-0.60.0.orig/numba/core/ir.py
+++ numba-0.60.0/numba/core/ir.py
@@ -90,9 +90,12 @@ class Loc(object):
 
     def get_lines(self):
         if self.lines is None:
-
-            self.lines = linecache.getlines(self._get_path())
-
+            path = self._get_path()
+            # Avoid reading from dynamic string. They are most likely
+            # overridden. Problem started with Python 3.13. "<string>" seems
+            # to be something from multiprocessing.
+            lns = [] if path == "<string>" else linecache.getlines(path)
+            self.lines = lns
         return self.lines
 
     def _get_path(self):
@@ -1496,7 +1499,7 @@ class FunctionIR(object):
         self.block_entry_vars = {}
 
     def derive(self, blocks, arg_count=None, arg_names=None,
-               force_non_generator=False):
+               force_non_generator=False, loc=None):
         """
         Derive a new function IR from this one, using the given blocks,
         and possibly modifying the argument count and generator flag.
@@ -1507,7 +1510,7 @@ class FunctionIR(object):
 
         new_ir = copy.copy(self)
         new_ir.blocks = blocks
-        new_ir.loc = firstblock.loc
+        new_ir.loc = firstblock.loc if loc is None else loc
         if force_non_generator:
             new_ir.is_generator = False
         if arg_count is not None:
Index: numba-0.60.0/numba/core/transforms.py
===================================================================
--- numba-0.60.0.orig/numba/core/transforms.py
+++ numba-0.60.0/numba/core/transforms.py
@@ -191,12 +191,20 @@ def _loop_lift_modify_blocks(func_ir, lo
     loopblocks = dict((k, blocks[k].copy()) for k in loopblockkeys)
     # Modify the loop blocks
     _loop_lift_prepare_loop_func(loopinfo, loopblocks)
-
+    # Since Python 3.13, [END_FOR, POP_TOP] sequence becomes the start of the
+    # block causing the block to have line number of the start of previous loop.
+    # Fix this using the loc of the first getiter.
+    getiter_exprs = []
+    for blk in loopblocks.values():
+        getiter_exprs.extend(blk.find_exprs(op="getiter"))
+    first_getiter = min(getiter_exprs, key=lambda x: x.loc.line)
+    loop_loc = first_getiter.loc
     # Create a new IR for the lifted loop
     lifted_ir = func_ir.derive(blocks=loopblocks,
                                arg_names=tuple(loopinfo.inputs),
                                arg_count=len(loopinfo.inputs),
-                               force_non_generator=True)
+                               force_non_generator=True,
+                               loc=loop_loc)
     liftedloop = LiftedLoop(lifted_ir,
                             typingctx, targetctx, flags, locals)
 
Index: numba-0.60.0/numba/tests/test_exceptions.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_exceptions.py
+++ numba-0.60.0/numba/tests/test_exceptions.py
@@ -6,6 +6,7 @@ from numba import jit, njit
 from numba.core import types, errors, utils
 from numba.tests.support import (TestCase, expected_failure_py311,
                                  expected_failure_py312,
+                                 expected_failure_py313,
                                  )
 import unittest
 
@@ -440,6 +441,7 @@ class TestRaising(TestCase):
 
     @expected_failure_py311
     @expected_failure_py312
+    @expected_failure_py313
     def test_dynamic_raise(self):
 
         @njit
Index: numba-0.60.0/numba/tests/test_try_except.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_try_except.py
+++ numba-0.60.0/numba/tests/test_try_except.py
@@ -8,12 +8,13 @@ from numba import njit, typed, objmode,
 from numba.core.utils import PYVERSION
 from numba.core import ir_utils, ir
 from numba.core.errors import (
-    UnsupportedError, CompilerError, NumbaPerformanceWarning, TypingError,
+    CompilerError, NumbaPerformanceWarning, TypingError,
+    UnsupportedBytecodeError,
 )
 from numba.tests.support import (
     TestCase, unittest, captured_stdout, MemoryLeakMixin,
     skip_parfors_unsupported, skip_unless_scipy, expected_failure_py311,
-    expected_failure_py312
+    expected_failure_py312, expected_failure_py313,
 )
 
 
@@ -372,7 +373,7 @@ class TestTryBareExcept(TestCase):
             except:    # noqa: E722
                 raise
 
-        with self.assertRaises(UnsupportedError) as raises:
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
             udt()
         self.assertIn(
             "The re-raising of an exception is not yet supported.",
@@ -459,7 +460,7 @@ class TestTryExceptCaught(TestCase):
                 return r
             return r
 
-        with self.assertRaises(UnsupportedError) as raises:
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
             udt(True)
         self.assertIn(
             "Exception object cannot be stored into variable (e)",
@@ -474,7 +475,7 @@ class TestTryExceptCaught(TestCase):
             except Exception:
                 raise
 
-        with self.assertRaises(UnsupportedError) as raises:
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
             udt()
         self.assertIn(
             "The re-raising of an exception is not yet supported.",
@@ -492,7 +493,7 @@ class TestTryExceptCaught(TestCase):
                 except Exception:
                     raise
 
-        with self.assertRaises(UnsupportedError) as raises:
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
             udt()
         self.assertIn(
             "The re-raising of an exception is not yet supported.",
@@ -692,6 +693,7 @@ class TestTryExceptOtherControlFlow(Test
 
     @expected_failure_py311
     @expected_failure_py312
+    @expected_failure_py313
     def test_objmode(self):
         @njit
         def udt():
@@ -712,6 +714,7 @@ class TestTryExceptOtherControlFlow(Test
 
     @expected_failure_py311
     @expected_failure_py312
+    @expected_failure_py313
     def test_objmode_output_type(self):
         def bar(x):
             return np.asarray(list(reversed(x.tolist())))
Index: numba-0.60.0/numba/tests/test_withlifting.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_withlifting.py
+++ numba-0.60.0/numba/tests/test_withlifting.py
@@ -16,7 +16,8 @@ from numba.tests.support import (MemoryL
                                  skip_unless_scipy, linux_only,
                                  strace_supported, strace,
                                  expected_failure_py311,
-                                 expected_failure_py312)
+                                 expected_failure_py312,
+                                 expected_failure_py313)
 from numba.core.utils import PYVERSION
 from numba.experimental import jitclass
 import unittest
@@ -280,6 +281,7 @@ class TestLiftCall(BaseTestWithLifting):
 
     @expected_failure_py311
     @expected_failure_py312
+    @expected_failure_py313
     def test_liftcall5(self):
         self.check_extracted_with(liftcall5, expect_count=1,
                                   expected_stdout="0\n1\n2\n3\n4\n5\nA\n")
@@ -719,6 +721,7 @@ class TestLiftObj(MemoryLeak, TestCase):
 
     @expected_failure_py311
     @expected_failure_py312
+    @expected_failure_py313
     def test_case19_recursion(self):
         def foo(x):
             with objmode_context():
@@ -1169,7 +1172,7 @@ class TestBogusContext(BaseTestWithLifti
             with open('') as f:
                 pass
 
-        with self.assertRaises(errors.UnsupportedError) as raises:
+        with self.assertRaises(errors.UnsupportedBytecodeError) as raises:
             foo()
 
         excstr = str(raises.exception)
Index: numba-0.60.0/numba/tests/test_sys_monitoring.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_sys_monitoring.py
+++ numba-0.60.0/numba/tests/test_sys_monitoring.py
@@ -4,7 +4,7 @@ import sys
 import threading
 import unittest
 from unittest.mock import Mock, call
-from numba.tests.support import TestCase, skip_unless_py312
+from numba.tests.support import TestCase
 from numba import jit, objmode
 from numba.core.utils import PYVERSION
 from numba.core.serialize import _numba_unpickle
@@ -21,7 +21,7 @@ def generate_usecase():
     return foo, call_foo
 
 
-if PYVERSION == (3, 12):
+if PYVERSION in ((3, 12), (3, 13)):
     PY_START = sys.monitoring.events.PY_START
     PY_RETURN = sys.monitoring.events.PY_RETURN
     RAISE = sys.monitoring.events.RAISE
@@ -36,7 +36,7 @@ TOOL2MONITORTYPE = {0 : "Debugger",
                     5 : "Optimizer"}
 
 
-@skip_unless_py312
+@unittest.skipUnless(PYVERSION >= (3, 12), "needs Python 3.12+")
 class TestMonitoring(TestCase):
     # Tests the interaction of the Numba dispatcher with `sys.monitoring`.
     #
@@ -724,7 +724,7 @@ class TestMonitoring(TestCase):
         self.assertFalse(q2.qsize())
 
 
-@skip_unless_py312
+@unittest.skipUnless(PYVERSION >= (3, 12), "needs Python 3.12+")
 class TestMonitoringSelfTest(TestCase):
 
     def test_skipping_of_tests_if_monitoring_in_use(self):
Index: numba-0.60.0/numba/_random.c
===================================================================
--- numba-0.60.0.orig/numba/_random.c
+++ numba-0.60.0/numba/_random.c
@@ -195,7 +195,7 @@ rnd_implicit_init(rnd_state_t *state)
     Py_buffer buf;
     PyGILState_STATE gilstate = PyGILState_Ensure();
 
-    module = PyImport_ImportModuleNoBlock("os");
+    module = PyImport_ImportModule("os");
     if (module == NULL)
         goto error;
     /* Read as many bytes as necessary to get the full entropy
Index: numba-0.60.0/numba/core/pythonapi.py
===================================================================
--- numba-0.60.0.orig/numba/core/pythonapi.py
+++ numba-0.60.0/numba/core/pythonapi.py
@@ -919,9 +919,9 @@ class PythonAPI(object):
     # Other APIs (organize them better!)
     #
 
-    def import_module_noblock(self, modname):
+    def import_module(self, modname):
         fnty = ir.FunctionType(self.pyobj, [self.cstring])
-        fn = self._get_function(fnty, name="PyImport_ImportModuleNoBlock")
+        fn = self._get_function(fnty, name="PyImport_ImportModule")
         return self.builder.call(fn, [modname])
 
     def call_function_objargs(self, callee, objargs):
Index: numba-0.60.0/numba/experimental/function_type.py
===================================================================
--- numba-0.60.0.orig/numba/experimental/function_type.py
+++ numba-0.60.0/numba/experimental/function_type.py
@@ -181,7 +181,7 @@ def lower_get_wrapper_address(context, b
     # caller.
 
     modname = context.insert_const_string(builder.module, __name__)
-    numba_mod = pyapi.import_module_noblock(modname)
+    numba_mod = pyapi.import_module(modname)
     numba_func = pyapi.object_getattr_string(
         numba_mod, '_get_wrapper_address')
     pyapi.decref(numba_mod)
@@ -263,3 +263,4 @@ def lower_cast_dispatcher_to_function_ty
     llty = context.get_value_type(types.voidptr)
     sfunc.pyaddr = builder.ptrtoint(val, llty)
     return sfunc._getvalue()
+
Index: numba-0.60.0/numba/typed/typeddict.py
===================================================================
--- numba-0.60.0.orig/numba/typed/typeddict.py
+++ numba-0.60.0/numba/typed/typeddict.py
@@ -266,7 +266,7 @@ def box_dicttype(typ, val, c):
     modname = c.context.insert_const_string(
         c.builder.module, 'numba.typed.typeddict',
     )
-    typeddict_mod = c.pyapi.import_module_noblock(modname)
+    typeddict_mod = c.pyapi.import_module(modname)
     fmp_fn = c.pyapi.object_getattr_string(typeddict_mod, '_from_meminfo_ptr')
 
     dicttype_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ))
Index: numba-0.60.0/numba/typed/typedlist.py
===================================================================
--- numba-0.60.0.orig/numba/typed/typedlist.py
+++ numba-0.60.0/numba/typed/typedlist.py
@@ -471,7 +471,7 @@ def box_lsttype(typ, val, c):
     modname = c.context.insert_const_string(
         c.builder.module, 'numba.typed.typedlist',
     )
-    typedlist_mod = c.pyapi.import_module_noblock(modname)
+    typedlist_mod = c.pyapi.import_module(modname)
     fmp_fn = c.pyapi.object_getattr_string(typedlist_mod, '_from_meminfo_ptr')
 
     lsttype_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ))
Index: numba-0.60.0/numba/tests/test_interpreter.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_interpreter.py
+++ numba-0.60.0/numba/tests/test_interpreter.py
@@ -5,7 +5,7 @@ import unittest
 from numba import jit, njit, objmode, typeof, literally
 from numba.extending import overload
 from numba.core import types
-from numba.core.errors import UnsupportedError
+from numba.core.errors import UnsupportedBytecodeError
 from numba.tests.support import (
     TestCase,
     MemoryLeakMixin,
@@ -388,7 +388,7 @@ class TestCallFunctionExPeepHole(MemoryL
                 arg41=1,
             )
 
-        with self.assertRaises(UnsupportedError) as raises:
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
             njit()(inline_func)(False)
         self.assertIn(
             'You can resolve this issue by moving the control flow out',
@@ -498,7 +498,7 @@ class TestCallFunctionExPeepHole(MemoryL
                 1,
             )
 
-        with self.assertRaises(UnsupportedError) as raises:
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
             njit()(inline_func)(False)
         self.assertIn(
             'You can resolve this issue by moving the control flow out',
@@ -585,7 +585,7 @@ class TestCallFunctionExPeepHole(MemoryL
                 arg15=1 if flag else 2,
             )
 
-        with self.assertRaises(UnsupportedError) as raises:
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
             njit()(inline_func)(False)
         self.assertIn(
             'You can resolve this issue by moving the control flow out',
@@ -973,7 +973,7 @@ class TestLargeConstDict(TestCase, Memor
             }
             return d["S"]
 
-        with self.assertRaises(UnsupportedError) as raises:
+        with self.assertRaises(UnsupportedBytecodeError) as raises:
             njit()(inline_func)("a_string", False)
         self.assertIn(
             'You can resolve this issue by moving the control flow out',
Index: numba-0.60.0/numba/tests/test_tuples.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_tuples.py
+++ numba-0.60.0/numba/tests/test_tuples.py
@@ -731,7 +731,7 @@ class TestTupleBuild(TestCase):
             b = (3,2,  4)
             return (*(b if a[0] else (5, 6)),)
 
-        with self.assertRaises(errors.UnsupportedError) as raises:
+        with self.assertRaises(errors.UnsupportedBytecodeError) as raises:
             foo()
         msg = "op_LIST_EXTEND at the start of a block"
         self.assertIn(msg, str(raises.exception))
Index: numba-0.60.0/setup.py
===================================================================
--- numba-0.60.0.orig/setup.py
+++ numba-0.60.0/setup.py
@@ -20,7 +20,7 @@ except ImportError:
 
 
 min_python_version = "3.9"
-max_python_version = "3.13"  # exclusive
+max_python_version = "3.14"  # exclusive
 min_numpy_build_version = "2.0.0rc1"
 min_numpy_run_version = "1.22"
 max_numpy_run_version = "2.1"
Index: numba-0.60.0/numba/core/boxing.py
===================================================================
--- numba-0.60.0.orig/numba/core/boxing.py
+++ numba-0.60.0/numba/core/boxing.py
@@ -655,7 +655,7 @@ class _NumbaTypeHelper(object):
     def __enter__(self):
         c = self.c
         numba_name = c.context.insert_const_string(c.builder.module, 'numba')
-        numba_mod = c.pyapi.import_module_noblock(numba_name)
+        numba_mod = c.pyapi.import_module(numba_name)
         typeof_fn = c.pyapi.object_getattr_string(numba_mod, 'typeof')
         self.typeof_fn = typeof_fn
         c.pyapi.decref(numba_mod)
@@ -1213,7 +1213,7 @@ def unbox_numpy_random_bitgenerator(typ,
         # store the results.
         # First find ctypes.cast, and ctypes.c_void_p
         ctypes_name = c.context.insert_const_string(c.builder.module, 'ctypes')
-        ctypes_module = c.pyapi.import_module_noblock(ctypes_name)
+        ctypes_module = c.pyapi.import_module(ctypes_name)
         extra_refs.append(ctypes_module)
         with cgutils.early_exit_if_null(c.builder, stack, ctypes_module):
             handle_failure()
Index: numba-0.60.0/numba/pythoncapi_compat.h
===================================================================
--- /dev/null
+++ numba-0.60.0/numba/pythoncapi_compat.h
@@ -0,0 +1,1696 @@
+// Header file providing new C API functions to old Python versions.
+//
+// File distributed under the Zero Clause BSD (0BSD) license.
+// Copyright Contributors to the pythoncapi_compat project.
+//
+// Homepage:
+// https://github.com/python/pythoncapi_compat
+//
+// Latest version:
+// https://raw.githubusercontent.com/python/pythoncapi-compat/0041177c4f348c8952b4c8980b2c90856e61c7c7/pythoncapi_compat.h
+//
+// SPDX-License-Identifier: 0BSD
+
+#ifndef PYTHONCAPI_COMPAT
+#define PYTHONCAPI_COMPAT
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <Python.h>
+
+// Python 3.11.0b4 added PyFrame_Back() to Python.h
+#if PY_VERSION_HEX < 0x030b00B4 && !defined(PYPY_VERSION)
+#  include "frameobject.h"        // PyFrameObject, PyFrame_GetBack()
+#endif
+
+
+#ifndef _Py_CAST
+#  define _Py_CAST(type, expr) ((type)(expr))
+#endif
+
+// Static inline functions should use _Py_NULL rather than using directly NULL
+// to prevent C++ compiler warnings. On C23 and newer and on C++11 and newer,
+// _Py_NULL is defined as nullptr.
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L) \
+        || (defined(__cplusplus) && __cplusplus >= 201103)
+#  define _Py_NULL nullptr
+#else
+#  define _Py_NULL NULL
+#endif
+
+// Cast argument to PyObject* type.
+#ifndef _PyObject_CAST
+#  define _PyObject_CAST(op) _Py_CAST(PyObject*, op)
+#endif
+
+#ifndef Py_BUILD_ASSERT
+#  define Py_BUILD_ASSERT(cond) \
+        do { \
+            (void)sizeof(char [1 - 2 * !(cond)]); \
+        } while(0)
+#endif
+
+
+// bpo-42262 added Py_NewRef() to Python 3.10.0a3
+#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_NewRef)
+static inline PyObject* _Py_NewRef(PyObject *obj)
+{
+    Py_INCREF(obj);
+    return obj;
+}
+#define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj))
+#endif
+
+
+// bpo-42262 added Py_XNewRef() to Python 3.10.0a3
+#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_XNewRef)
+static inline PyObject* _Py_XNewRef(PyObject *obj)
+{
+    Py_XINCREF(obj);
+    return obj;
+}
+#define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj))
+#endif
+
+
+// bpo-39573 added Py_SET_REFCNT() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_REFCNT)
+static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt)
+{
+    ob->ob_refcnt = refcnt;
+}
+#define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob), refcnt)
+#endif
+
+
+// Py_SETREF() and Py_XSETREF() were added to Python 3.5.2.
+// It is excluded from the limited C API.
+#if (PY_VERSION_HEX < 0x03050200 && !defined(Py_SETREF)) && !defined(Py_LIMITED_API)
+#define Py_SETREF(dst, src)                                     \
+    do {                                                        \
+        PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \
+        PyObject *_tmp_dst = (*_tmp_dst_ptr);                   \
+        *_tmp_dst_ptr = _PyObject_CAST(src);                    \
+        Py_DECREF(_tmp_dst);                                    \
+    } while (0)
+
+#define Py_XSETREF(dst, src)                                    \
+    do {                                                        \
+        PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \
+        PyObject *_tmp_dst = (*_tmp_dst_ptr);                   \
+        *_tmp_dst_ptr = _PyObject_CAST(src);                    \
+        Py_XDECREF(_tmp_dst);                                   \
+    } while (0)
+#endif
+
+
+// bpo-43753 added Py_Is(), Py_IsNone(), Py_IsTrue() and Py_IsFalse()
+// to Python 3.10.0b1.
+#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_Is)
+#  define Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_IsNone)
+#  define Py_IsNone(x) Py_Is(x, Py_None)
+#endif
+#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsTrue)
+#  define Py_IsTrue(x) Py_Is(x, Py_True)
+#endif
+#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsFalse)
+#  define Py_IsFalse(x) Py_Is(x, Py_False)
+#endif
+
+
+// bpo-39573 added Py_SET_TYPE() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_TYPE)
+static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type)
+{
+    ob->ob_type = type;
+}
+#define Py_SET_TYPE(ob, type) _Py_SET_TYPE(_PyObject_CAST(ob), type)
+#endif
+
+
+// bpo-39573 added Py_SET_SIZE() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_SIZE)
+static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size)
+{
+    ob->ob_size = size;
+}
+#define Py_SET_SIZE(ob, size) _Py_SET_SIZE((PyVarObject*)(ob), size)
+#endif
+
+
+// bpo-40421 added PyFrame_GetCode() to Python 3.9.0b1
+#if PY_VERSION_HEX < 0x030900B1 || defined(PYPY_VERSION)
+static inline PyCodeObject* PyFrame_GetCode(PyFrameObject *frame)
+{
+    assert(frame != _Py_NULL);
+    assert(frame->f_code != _Py_NULL);
+    return _Py_CAST(PyCodeObject*, Py_NewRef(frame->f_code));
+}
+#endif
+
+static inline PyCodeObject* _PyFrame_GetCodeBorrow(PyFrameObject *frame)
+{
+    PyCodeObject *code = PyFrame_GetCode(frame);
+    Py_DECREF(code);
+    return code;
+}
+
+
+// bpo-40421 added PyFrame_GetBack() to Python 3.9.0b1
+#if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION)
+static inline PyFrameObject* PyFrame_GetBack(PyFrameObject *frame)
+{
+    assert(frame != _Py_NULL);
+    return _Py_CAST(PyFrameObject*, Py_XNewRef(frame->f_back));
+}
+#endif
+
+#if !defined(PYPY_VERSION)
+static inline PyFrameObject* _PyFrame_GetBackBorrow(PyFrameObject *frame)
+{
+    PyFrameObject *back = PyFrame_GetBack(frame);
+    Py_XDECREF(back);
+    return back;
+}
+#endif
+
+
+// bpo-40421 added PyFrame_GetLocals() to Python 3.11.0a7
+#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetLocals(PyFrameObject *frame)
+{
+#if PY_VERSION_HEX >= 0x030400B1
+    if (PyFrame_FastToLocalsWithError(frame) < 0) {
+        return NULL;
+    }
+#else
+    PyFrame_FastToLocals(frame);
+#endif
+    return Py_NewRef(frame->f_locals);
+}
+#endif
+
+
+// bpo-40421 added PyFrame_GetGlobals() to Python 3.11.0a7
+#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetGlobals(PyFrameObject *frame)
+{
+    return Py_NewRef(frame->f_globals);
+}
+#endif
+
+
+// bpo-40421 added PyFrame_GetBuiltins() to Python 3.11.0a7
+#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetBuiltins(PyFrameObject *frame)
+{
+    return Py_NewRef(frame->f_builtins);
+}
+#endif
+
+
+// bpo-40421 added PyFrame_GetLasti() to Python 3.11.0b1
+#if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION)
+static inline int PyFrame_GetLasti(PyFrameObject *frame)
+{
+#if PY_VERSION_HEX >= 0x030A00A7
+    // bpo-27129: Since Python 3.10.0a7, f_lasti is an instruction offset,
+    // not a bytes offset anymore. Python uses 16-bit "wordcode" (2 bytes)
+    // instructions.
+    if (frame->f_lasti < 0) {
+        return -1;
+    }
+    return frame->f_lasti * 2;
+#else
+    return frame->f_lasti;
+#endif
+}
+#endif
+
+
+// gh-91248 added PyFrame_GetVar() to Python 3.12.0a2
+#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetVar(PyFrameObject *frame, PyObject *name)
+{
+    PyObject *locals, *value;
+
+    locals = PyFrame_GetLocals(frame);
+    if (locals == NULL) {
+        return NULL;
+    }
+#if PY_VERSION_HEX >= 0x03000000
+    value = PyDict_GetItemWithError(locals, name);
+#else
+    value = _PyDict_GetItemWithError(locals, name);
+#endif
+    Py_DECREF(locals);
+
+    if (value == NULL) {
+        if (PyErr_Occurred()) {
+            return NULL;
+        }
+#if PY_VERSION_HEX >= 0x03000000
+        PyErr_Format(PyExc_NameError, "variable %R does not exist", name);
+#else
+        PyErr_SetString(PyExc_NameError, "variable does not exist");
+#endif
+        return NULL;
+    }
+    return Py_NewRef(value);
+}
+#endif
+
+
+// gh-91248 added PyFrame_GetVarString() to Python 3.12.0a2
+#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION)
+static inline PyObject*
+PyFrame_GetVarString(PyFrameObject *frame, const char *name)
+{
+    PyObject *name_obj, *value;
+#if PY_VERSION_HEX >= 0x03000000
+    name_obj = PyUnicode_FromString(name);
+#else
+    name_obj = PyString_FromString(name);
+#endif
+    if (name_obj == NULL) {
+        return NULL;
+    }
+    value = PyFrame_GetVar(frame, name_obj);
+    Py_DECREF(name_obj);
+    return value;
+}
+#endif
+
+
+// bpo-39947 added PyThreadState_GetInterpreter() to Python 3.9.0a5
+#if PY_VERSION_HEX < 0x030900A5 || defined(PYPY_VERSION)
+static inline PyInterpreterState *
+PyThreadState_GetInterpreter(PyThreadState *tstate)
+{
+    assert(tstate != _Py_NULL);
+    return tstate->interp;
+}
+#endif
+
+
+// bpo-40429 added PyThreadState_GetFrame() to Python 3.9.0b1
+#if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION)
+static inline PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate)
+{
+    assert(tstate != _Py_NULL);
+    return _Py_CAST(PyFrameObject *, Py_XNewRef(tstate->frame));
+}
+#endif
+
+#if !defined(PYPY_VERSION)
+static inline PyFrameObject*
+_PyThreadState_GetFrameBorrow(PyThreadState *tstate)
+{
+    PyFrameObject *frame = PyThreadState_GetFrame(tstate);
+    Py_XDECREF(frame);
+    return frame;
+}
+#endif
+
+
+// bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a5
+#if PY_VERSION_HEX < 0x030900A5 || defined(PYPY_VERSION)
+static inline PyInterpreterState* PyInterpreterState_Get(void)
+{
+    PyThreadState *tstate;
+    PyInterpreterState *interp;
+
+    tstate = PyThreadState_GET();
+    if (tstate == _Py_NULL) {
+        Py_FatalError("GIL released (tstate is NULL)");
+    }
+    interp = tstate->interp;
+    if (interp == _Py_NULL) {
+        Py_FatalError("no current interpreter");
+    }
+    return interp;
+}
+#endif
+
+
+// bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a6
+#if 0x030700A1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION)
+static inline uint64_t PyThreadState_GetID(PyThreadState *tstate)
+{
+    assert(tstate != _Py_NULL);
+    return tstate->id;
+}
+#endif
+
+// bpo-43760 added PyThreadState_EnterTracing() to Python 3.11.0a2
+#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
+static inline void PyThreadState_EnterTracing(PyThreadState *tstate)
+{
+    tstate->tracing++;
+#if PY_VERSION_HEX >= 0x030A00A1
+    tstate->cframe->use_tracing = 0;
+#else
+    tstate->use_tracing = 0;
+#endif
+}
+#endif
+
+// bpo-43760 added PyThreadState_LeaveTracing() to Python 3.11.0a2
+#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
+static inline void PyThreadState_LeaveTracing(PyThreadState *tstate)
+{
+    int use_tracing = (tstate->c_tracefunc != _Py_NULL
+                       || tstate->c_profilefunc != _Py_NULL);
+    tstate->tracing--;
+#if PY_VERSION_HEX >= 0x030A00A1
+    tstate->cframe->use_tracing = use_tracing;
+#else
+    tstate->use_tracing = use_tracing;
+#endif
+}
+#endif
+
+
+// bpo-37194 added PyObject_CallNoArgs() to Python 3.9.0a1
+// PyObject_CallNoArgs() added to PyPy 3.9.16-v7.3.11
+#if !defined(PyObject_CallNoArgs) && PY_VERSION_HEX < 0x030900A1
+static inline PyObject* PyObject_CallNoArgs(PyObject *func)
+{
+    return PyObject_CallFunctionObjArgs(func, NULL);
+}
+#endif
+
+
+// bpo-39245 made PyObject_CallOneArg() public (previously called
+// _PyObject_CallOneArg) in Python 3.9.0a4
+// PyObject_CallOneArg() added to PyPy 3.9.16-v7.3.11
+#if !defined(PyObject_CallOneArg) && PY_VERSION_HEX < 0x030900A4
+static inline PyObject* PyObject_CallOneArg(PyObject *func, PyObject *arg)
+{
+    return PyObject_CallFunctionObjArgs(func, arg, NULL);
+}
+#endif
+
+
+// bpo-1635741 added PyModule_AddObjectRef() to Python 3.10.0a3
+#if PY_VERSION_HEX < 0x030A00A3
+static inline int
+PyModule_AddObjectRef(PyObject *module, const char *name, PyObject *value)
+{
+    int res;
+
+    if (!value && !PyErr_Occurred()) {
+        // PyModule_AddObject() raises TypeError in this case
+        PyErr_SetString(PyExc_SystemError,
+                        "PyModule_AddObjectRef() must be called "
+                        "with an exception raised if value is NULL");
+        return -1;
+    }
+
+    Py_XINCREF(value);
+    res = PyModule_AddObject(module, name, value);
+    if (res < 0) {
+        Py_XDECREF(value);
+    }
+    return res;
+}
+#endif
+
+
+// bpo-40024 added PyModule_AddType() to Python 3.9.0a5
+#if PY_VERSION_HEX < 0x030900A5
+static inline int PyModule_AddType(PyObject *module, PyTypeObject *type)
+{
+    const char *name, *dot;
+
+    if (PyType_Ready(type) < 0) {
+        return -1;
+    }
+
+    // inline _PyType_Name()
+    name = type->tp_name;
+    assert(name != _Py_NULL);
+    dot = strrchr(name, '.');
+    if (dot != _Py_NULL) {
+        name = dot + 1;
+    }
+
+    return PyModule_AddObjectRef(module, name, _PyObject_CAST(type));
+}
+#endif
+
+
+// bpo-40241 added PyObject_GC_IsTracked() to Python 3.9.0a6.
+// bpo-4688 added _PyObject_GC_IS_TRACKED() to Python 2.7.0a2.
+#if PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION)
+static inline int PyObject_GC_IsTracked(PyObject* obj)
+{
+    return (PyObject_IS_GC(obj) && _PyObject_GC_IS_TRACKED(obj));
+}
+#endif
+
+// bpo-40241 added PyObject_GC_IsFinalized() to Python 3.9.0a6.
+// bpo-18112 added _PyGCHead_FINALIZED() to Python 3.4.0 final.
+#if PY_VERSION_HEX < 0x030900A6 && PY_VERSION_HEX >= 0x030400F0 && !defined(PYPY_VERSION)
+static inline int PyObject_GC_IsFinalized(PyObject *obj)
+{
+    PyGC_Head *gc = _Py_CAST(PyGC_Head*, obj) - 1;
+    return (PyObject_IS_GC(obj) && _PyGCHead_FINALIZED(gc));
+}
+#endif
+
+
+// bpo-39573 added Py_IS_TYPE() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_IS_TYPE)
+static inline int _Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
+    return Py_TYPE(ob) == type;
+}
+#define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST(ob), type)
+#endif
+
+
+// bpo-46906 added PyFloat_Pack2() and PyFloat_Unpack2() to Python 3.11a7.
+// bpo-11734 added _PyFloat_Pack2() and _PyFloat_Unpack2() to Python 3.6.0b1.
+// Python 3.11a2 moved _PyFloat_Pack2() and _PyFloat_Unpack2() to the internal
+// C API: Python 3.11a2-3.11a6 versions are not supported.
+#if 0x030600B1 <= PY_VERSION_HEX && PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION)
+static inline int PyFloat_Pack2(double x, char *p, int le)
+{ return _PyFloat_Pack2(x, (unsigned char*)p, le); }
+
+static inline double PyFloat_Unpack2(const char *p, int le)
+{ return _PyFloat_Unpack2((const unsigned char *)p, le); }
+#endif
+
+
+// bpo-46906 added PyFloat_Pack4(), PyFloat_Pack8(), PyFloat_Unpack4() and
+// PyFloat_Unpack8() to Python 3.11a7.
+// Python 3.11a2 moved _PyFloat_Pack4(), _PyFloat_Pack8(), _PyFloat_Unpack4()
+// and _PyFloat_Unpack8() to the internal C API: Python 3.11a2-3.11a6 versions
+// are not supported.
+#if PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION)
+static inline int PyFloat_Pack4(double x, char *p, int le)
+{ return _PyFloat_Pack4(x, (unsigned char*)p, le); }
+
+static inline int PyFloat_Pack8(double x, char *p, int le)
+{ return _PyFloat_Pack8(x, (unsigned char*)p, le); }
+
+static inline double PyFloat_Unpack4(const char *p, int le)
+{ return _PyFloat_Unpack4((const unsigned char *)p, le); }
+
+static inline double PyFloat_Unpack8(const char *p, int le)
+{ return _PyFloat_Unpack8((const unsigned char *)p, le); }
+#endif
+
+
+// gh-92154 added PyCode_GetCode() to Python 3.11.0b1
+#if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetCode(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_code);
+}
+#endif
+
+
+// gh-95008 added PyCode_GetVarnames() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetVarnames(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_varnames);
+}
+#endif
+
+// gh-95008 added PyCode_GetFreevars() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetFreevars(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_freevars);
+}
+#endif
+
+// gh-95008 added PyCode_GetCellvars() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetCellvars(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_cellvars);
+}
+#endif
+
+
+// Py_UNUSED() was added to Python 3.4.0b2.
+#if PY_VERSION_HEX < 0x030400B2 && !defined(Py_UNUSED)
+#  if defined(__GNUC__) || defined(__clang__)
+#    define Py_UNUSED(name) _unused_ ## name __attribute__((unused))
+#  else
+#    define Py_UNUSED(name) _unused_ ## name
+#  endif
+#endif
+
+
+// gh-105922 added PyImport_AddModuleRef() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A0
+static inline PyObject* PyImport_AddModuleRef(const char *name)
+{
+    return Py_XNewRef(PyImport_AddModule(name));
+}
+#endif
+
+
+// gh-105927 added PyWeakref_GetRef() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D0000
+static inline int PyWeakref_GetRef(PyObject *ref, PyObject **pobj)
+{
+    PyObject *obj;
+    if (ref != NULL && !PyWeakref_Check(ref)) {
+        *pobj = NULL;
+        PyErr_SetString(PyExc_TypeError, "expected a weakref");
+        return -1;
+    }
+    obj = PyWeakref_GetObject(ref);
+    if (obj == NULL) {
+        // SystemError if ref is NULL
+        *pobj = NULL;
+        return -1;
+    }
+    if (obj == Py_None) {
+        *pobj = NULL;
+        return 0;
+    }
+    *pobj = Py_NewRef(obj);
+    return (*pobj != NULL);
+}
+#endif
+
+
+// bpo-36974 added PY_VECTORCALL_ARGUMENTS_OFFSET to Python 3.8b1
+#ifndef PY_VECTORCALL_ARGUMENTS_OFFSET
+#  define PY_VECTORCALL_ARGUMENTS_OFFSET (_Py_CAST(size_t, 1) << (8 * sizeof(size_t) - 1))
+#endif
+
+// bpo-36974 added PyVectorcall_NARGS() to Python 3.8b1
+#if PY_VERSION_HEX < 0x030800B1
+static inline Py_ssize_t PyVectorcall_NARGS(size_t n)
+{
+    return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET;
+}
+#endif
+
+
+// gh-105922 added PyObject_Vectorcall() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4
+static inline PyObject*
+PyObject_Vectorcall(PyObject *callable, PyObject *const *args,
+                     size_t nargsf, PyObject *kwnames)
+{
+#if PY_VERSION_HEX >= 0x030800B1 && !defined(PYPY_VERSION)
+    // bpo-36974 added _PyObject_Vectorcall() to Python 3.8.0b1
+    return _PyObject_Vectorcall(callable, args, nargsf, kwnames);
+#else
+    PyObject *posargs = NULL, *kwargs = NULL;
+    PyObject *res;
+    Py_ssize_t nposargs, nkwargs, i;
+
+    if (nargsf != 0 && args == NULL) {
+        PyErr_BadInternalCall();
+        goto error;
+    }
+    if (kwnames != NULL && !PyTuple_Check(kwnames)) {
+        PyErr_BadInternalCall();
+        goto error;
+    }
+
+    nposargs = (Py_ssize_t)PyVectorcall_NARGS(nargsf);
+    if (kwnames) {
+        nkwargs = PyTuple_GET_SIZE(kwnames);
+    }
+    else {
+        nkwargs = 0;
+    }
+
+    posargs = PyTuple_New(nposargs);
+    if (posargs == NULL) {
+        goto error;
+    }
+    if (nposargs) {
+        for (i=0; i < nposargs; i++) {
+            PyTuple_SET_ITEM(posargs, i, Py_NewRef(*args));
+            args++;
+        }
+    }
+
+    if (nkwargs) {
+        kwargs = PyDict_New();
+        if (kwargs == NULL) {
+            goto error;
+        }
+
+        for (i = 0; i < nkwargs; i++) {
+            PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+            PyObject *value = *args;
+            args++;
+            if (PyDict_SetItem(kwargs, key, value) < 0) {
+                goto error;
+            }
+        }
+    }
+    else {
+        kwargs = NULL;
+    }
+
+    res = PyObject_Call(callable, posargs, kwargs);
+    Py_DECREF(posargs);
+    Py_XDECREF(kwargs);
+    return res;
+
+error:
+    Py_DECREF(posargs);
+    Py_XDECREF(kwargs);
+    return NULL;
+#endif
+}
+#endif
+
+
+// gh-106521 added PyObject_GetOptionalAttr() and
+// PyObject_GetOptionalAttrString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_GetOptionalAttr(PyObject *obj, PyObject *attr_name, PyObject **result)
+{
+    // bpo-32571 added _PyObject_LookupAttr() to Python 3.7.0b1
+#if PY_VERSION_HEX >= 0x030700B1 && !defined(PYPY_VERSION)
+    return _PyObject_LookupAttr(obj, attr_name, result);
+#else
+    *result = PyObject_GetAttr(obj, attr_name);
+    if (*result != NULL) {
+        return 1;
+    }
+    if (!PyErr_Occurred()) {
+        return 0;
+    }
+    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        return 0;
+    }
+    return -1;
+#endif
+}
+
+static inline int
+PyObject_GetOptionalAttrString(PyObject *obj, const char *attr_name, PyObject **result)
+{
+    PyObject *name_obj;
+    int rc;
+#if PY_VERSION_HEX >= 0x03000000
+    name_obj = PyUnicode_FromString(attr_name);
+#else
+    name_obj = PyString_FromString(attr_name);
+#endif
+    if (name_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    rc = PyObject_GetOptionalAttr(obj, name_obj, result);
+    Py_DECREF(name_obj);
+    return rc;
+}
+#endif
+
+
+// gh-106307 added PyObject_GetOptionalAttr() and
+// PyMapping_GetOptionalItemString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyMapping_GetOptionalItem(PyObject *obj, PyObject *key, PyObject **result)
+{
+    *result = PyObject_GetItem(obj, key);
+    if (*result) {
+        return 1;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_KeyError)) {
+        return -1;
+    }
+    PyErr_Clear();
+    return 0;
+}
+
+static inline int
+PyMapping_GetOptionalItemString(PyObject *obj, const char *key, PyObject **result)
+{
+    PyObject *key_obj;
+    int rc;
+#if PY_VERSION_HEX >= 0x03000000
+    key_obj = PyUnicode_FromString(key);
+#else
+    key_obj = PyString_FromString(key);
+#endif
+    if (key_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    rc = PyMapping_GetOptionalItem(obj, key_obj, result);
+    Py_DECREF(key_obj);
+    return rc;
+}
+#endif
+
+// gh-108511 added PyMapping_HasKeyWithError() and
+// PyMapping_HasKeyStringWithError() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyMapping_HasKeyWithError(PyObject *obj, PyObject *key)
+{
+    PyObject *res;
+    int rc = PyMapping_GetOptionalItem(obj, key, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+
+static inline int
+PyMapping_HasKeyStringWithError(PyObject *obj, const char *key)
+{
+    PyObject *res;
+    int rc = PyMapping_GetOptionalItemString(obj, key, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+#endif
+
+
+// gh-108511 added PyObject_HasAttrWithError() and
+// PyObject_HasAttrStringWithError() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_HasAttrWithError(PyObject *obj, PyObject *attr)
+{
+    PyObject *res;
+    int rc = PyObject_GetOptionalAttr(obj, attr, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+
+static inline int
+PyObject_HasAttrStringWithError(PyObject *obj, const char *attr)
+{
+    PyObject *res;
+    int rc = PyObject_GetOptionalAttrString(obj, attr, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+#endif
+
+
+// gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef()
+// to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *item = PyDict_GetItemWithError(mp, key);
+#else
+    PyObject *item = _PyDict_GetItemWithError(mp, key);
+#endif
+    if (item != NULL) {
+        *result = Py_NewRef(item);
+        return 1;  // found
+    }
+    if (!PyErr_Occurred()) {
+        *result = NULL;
+        return 0;  // not found
+    }
+    *result = NULL;
+    return -1;
+}
+
+static inline int
+PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result)
+{
+    int res;
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *key_obj = PyUnicode_FromString(key);
+#else
+    PyObject *key_obj = PyString_FromString(key);
+#endif
+    if (key_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    res = PyDict_GetItemRef(mp, key_obj, result);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+// gh-106307 added PyModule_Add() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyModule_Add(PyObject *mod, const char *name, PyObject *value)
+{
+    int res = PyModule_AddObjectRef(mod, name, value);
+    Py_XDECREF(value);
+    return res;
+}
+#endif
+
+
+// gh-108014 added Py_IsFinalizing() to Python 3.13.0a1
+// bpo-1856 added _Py_Finalizing to Python 3.2.1b1.
+// _Py_IsFinalizing() was added to PyPy 7.3.0.
+#if (0x030201B1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030D00A1) \
+        && (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x7030000)
+static inline int Py_IsFinalizing(void)
+{
+#if PY_VERSION_HEX >= 0x030700A1
+    // _Py_IsFinalizing() was added to Python 3.7.0a1.
+    return _Py_IsFinalizing();
+#else
+    return (_Py_Finalizing != NULL);
+#endif
+}
+#endif
+
+
+// gh-108323 added PyDict_ContainsString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int PyDict_ContainsString(PyObject *op, const char *key)
+{
+    PyObject *key_obj = PyUnicode_FromString(key);
+    if (key_obj == NULL) {
+        return -1;
+    }
+    int res = PyDict_Contains(op, key_obj);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+// gh-108445 added PyLong_AsInt() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int PyLong_AsInt(PyObject *obj)
+{
+#ifdef PYPY_VERSION
+    long value = PyLong_AsLong(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    if (value < (long)INT_MIN || (long)INT_MAX < value) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "Python int too large to convert to C int");
+        return -1;
+    }
+    return (int)value;
+#else
+    return _PyLong_AsInt(obj);
+#endif
+}
+#endif
+
+
+// gh-107073 added PyObject_VisitManagedDict() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg)
+{
+    PyObject **dict = _PyObject_GetDictPtr(obj);
+    if (*dict == NULL) {
+        return -1;
+    }
+    Py_VISIT(*dict);
+    return 0;
+}
+
+static inline void
+PyObject_ClearManagedDict(PyObject *obj)
+{
+    PyObject **dict = _PyObject_GetDictPtr(obj);
+    if (*dict == NULL) {
+        return;
+    }
+    Py_CLEAR(*dict);
+}
+#endif
+
+// gh-108867 added PyThreadState_GetUnchecked() to Python 3.13.0a1
+// Python 3.5.2 added _PyThreadState_UncheckedGet().
+#if PY_VERSION_HEX >= 0x03050200 && PY_VERSION_HEX < 0x030D00A1
+static inline PyThreadState*
+PyThreadState_GetUnchecked(void)
+{
+    return _PyThreadState_UncheckedGet();
+}
+#endif
+
+// gh-110289 added PyUnicode_EqualToUTF8() and PyUnicode_EqualToUTF8AndSize()
+// to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyUnicode_EqualToUTF8AndSize(PyObject *unicode, const char *str, Py_ssize_t str_len)
+{
+    Py_ssize_t len;
+    const void *utf8;
+    PyObject *exc_type, *exc_value, *exc_tb;
+    int res;
+
+    // API cannot report errors so save/restore the exception
+    PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
+
+    // Python 3.3.0a1 added PyUnicode_AsUTF8AndSize()
+#if PY_VERSION_HEX >= 0x030300A1
+    if (PyUnicode_IS_ASCII(unicode)) {
+        utf8 = PyUnicode_DATA(unicode);
+        len = PyUnicode_GET_LENGTH(unicode);
+    }
+    else {
+        utf8 = PyUnicode_AsUTF8AndSize(unicode, &len);
+        if (utf8 == NULL) {
+            // Memory allocation failure. The API cannot report error,
+            // so ignore the exception and return 0.
+            res = 0;
+            goto done;
+        }
+    }
+
+    if (len != str_len) {
+        res = 0;
+        goto done;
+    }
+    res = (memcmp(utf8, str, (size_t)len) == 0);
+#else
+    PyObject *bytes = PyUnicode_AsUTF8String(unicode);
+    if (bytes == NULL) {
+        // Memory allocation failure. The API cannot report error,
+        // so ignore the exception and return 0.
+        res = 0;
+        goto done;
+    }
+
+#if PY_VERSION_HEX >= 0x03000000
+    len = PyBytes_GET_SIZE(bytes);
+    utf8 = PyBytes_AS_STRING(bytes);
+#else
+    len = PyString_GET_SIZE(bytes);
+    utf8 = PyString_AS_STRING(bytes);
+#endif
+    if (len != str_len) {
+        Py_DECREF(bytes);
+        res = 0;
+        goto done;
+    }
+
+    res = (memcmp(utf8, str, (size_t)len) == 0);
+    Py_DECREF(bytes);
+#endif
+
+done:
+    PyErr_Restore(exc_type, exc_value, exc_tb);
+    return res;
+}
+
+static inline int
+PyUnicode_EqualToUTF8(PyObject *unicode, const char *str)
+{
+    return PyUnicode_EqualToUTF8AndSize(unicode, str, (Py_ssize_t)strlen(str));
+}
+#endif
+
+
+// gh-111138 added PyList_Extend() and PyList_Clear() to Python 3.13.0a2
+#if PY_VERSION_HEX < 0x030D00A2
+static inline int
+PyList_Extend(PyObject *list, PyObject *iterable)
+{
+    return PyList_SetSlice(list, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, iterable);
+}
+
+static inline int
+PyList_Clear(PyObject *list)
+{
+    return PyList_SetSlice(list, 0, PY_SSIZE_T_MAX, NULL);
+}
+#endif
+
+// gh-111262 added PyDict_Pop() and PyDict_PopString() to Python 3.13.0a2
+#if PY_VERSION_HEX < 0x030D00A2
+static inline int
+PyDict_Pop(PyObject *dict, PyObject *key, PyObject **result)
+{
+    PyObject *value;
+
+    if (!PyDict_Check(dict)) {
+        PyErr_BadInternalCall();
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+
+    // bpo-16991 added _PyDict_Pop() to Python 3.5.0b2.
+    // Python 3.6.0b3 changed _PyDict_Pop() first argument type to PyObject*.
+    // Python 3.13.0a1 removed _PyDict_Pop().
+#if defined(PYPY_VERSION) || PY_VERSION_HEX < 0x030500b2 || PY_VERSION_HEX >= 0x030D0000
+    value = PyObject_CallMethod(dict, "pop", "O", key);
+#elif PY_VERSION_HEX < 0x030600b3
+    value = _PyDict_Pop(_Py_CAST(PyDictObject*, dict), key, NULL);
+#else
+    value = _PyDict_Pop(dict, key, NULL);
+#endif
+    if (value == NULL) {
+        if (result) {
+            *result = NULL;
+        }
+        if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_KeyError)) {
+            return -1;
+        }
+        PyErr_Clear();
+        return 0;
+    }
+    if (result) {
+        *result = value;
+    }
+    else {
+        Py_DECREF(value);
+    }
+    return 1;
+}
+
+static inline int
+PyDict_PopString(PyObject *dict, const char *key, PyObject **result)
+{
+    PyObject *key_obj = PyUnicode_FromString(key);
+    if (key_obj == NULL) {
+        if (result != NULL) {
+            *result = NULL;
+        }
+        return -1;
+    }
+
+    int res = PyDict_Pop(dict, key_obj, result);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030200A4
+// Python 3.2.0a4 added Py_hash_t type
+typedef Py_ssize_t Py_hash_t;
+#endif
+
+
+// gh-111545 added Py_HashPointer() to Python 3.13.0a3
+#if PY_VERSION_HEX < 0x030D00A3
+static inline Py_hash_t Py_HashPointer(const void *ptr)
+{
+#if PY_VERSION_HEX >= 0x030900A4 && !defined(PYPY_VERSION)
+    return _Py_HashPointer(ptr);
+#else
+    return _Py_HashPointer(_Py_CAST(void*, ptr));
+#endif
+}
+#endif
+
+
+// Python 3.13a4 added a PyTime API.
+// Use the private API added to Python 3.5.
+#if PY_VERSION_HEX < 0x030D00A4 && PY_VERSION_HEX  >= 0x03050000
+typedef _PyTime_t PyTime_t;
+#define PyTime_MIN _PyTime_MIN
+#define PyTime_MAX _PyTime_MAX
+
+static inline double PyTime_AsSecondsDouble(PyTime_t t)
+{ return _PyTime_AsSecondsDouble(t); }
+
+static inline int PyTime_Monotonic(PyTime_t *result)
+{ return _PyTime_GetMonotonicClockWithInfo(result, NULL); }
+
+static inline int PyTime_Time(PyTime_t *result)
+{ return _PyTime_GetSystemClockWithInfo(result, NULL); }
+
+static inline int PyTime_PerfCounter(PyTime_t *result)
+{
+#if PY_VERSION_HEX >= 0x03070000 && !defined(PYPY_VERSION)
+    return _PyTime_GetPerfCounterWithInfo(result, NULL);
+#elif PY_VERSION_HEX >= 0x03070000
+    // Call time.perf_counter_ns() and convert Python int object to PyTime_t.
+    // Cache time.perf_counter_ns() function for best performance.
+    static PyObject *func = NULL;
+    if (func == NULL) {
+        PyObject *mod = PyImport_ImportModule("time");
+        if (mod == NULL) {
+            return -1;
+        }
+
+        func = PyObject_GetAttrString(mod, "perf_counter_ns");
+        Py_DECREF(mod);
+        if (func == NULL) {
+            return -1;
+        }
+    }
+
+    PyObject *res = PyObject_CallNoArgs(func);
+    if (res == NULL) {
+        return -1;
+    }
+    long long value = PyLong_AsLongLong(res);
+    Py_DECREF(res);
+
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+
+    Py_BUILD_ASSERT(sizeof(value) >= sizeof(PyTime_t));
+    *result = (PyTime_t)value;
+    return 0;
+#else
+    // Call time.perf_counter() and convert C double to PyTime_t.
+    // Cache time.perf_counter() function for best performance.
+    static PyObject *func = NULL;
+    if (func == NULL) {
+        PyObject *mod = PyImport_ImportModule("time");
+        if (mod == NULL) {
+            return -1;
+        }
+
+        func = PyObject_GetAttrString(mod, "perf_counter");
+        Py_DECREF(mod);
+        if (func == NULL) {
+            return -1;
+        }
+    }
+
+    PyObject *res = PyObject_CallNoArgs(func);
+    if (res == NULL) {
+        return -1;
+    }
+    double d = PyFloat_AsDouble(res);
+    Py_DECREF(res);
+
+    if (d == -1.0 && PyErr_Occurred()) {
+        return -1;
+    }
+
+    // Avoid floor() to avoid having to link to libm
+    *result = (PyTime_t)(d * 1e9);
+    return 0;
+#endif
+}
+
+#endif
+
+// gh-111389 added hash constants to Python 3.13.0a5. These constants were
+// added first as private macros to Python 3.4.0b1 and PyPy 7.3.9.
+#if (!defined(PyHASH_BITS) \
+     && ((!defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x030400B1) \
+         || (defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x03070000 \
+             && PYPY_VERSION_NUM >= 0x07090000)))
+#  define PyHASH_BITS _PyHASH_BITS
+#  define PyHASH_MODULUS _PyHASH_MODULUS
+#  define PyHASH_INF _PyHASH_INF
+#  define PyHASH_IMAG _PyHASH_IMAG
+#endif
+
+
+// gh-111545 added Py_GetConstant() and Py_GetConstantBorrowed()
+// to Python 3.13.0a6
+#if PY_VERSION_HEX < 0x030D00A6 && !defined(Py_CONSTANT_NONE)
+
+#define Py_CONSTANT_NONE 0
+#define Py_CONSTANT_FALSE 1
+#define Py_CONSTANT_TRUE 2
+#define Py_CONSTANT_ELLIPSIS 3
+#define Py_CONSTANT_NOT_IMPLEMENTED 4
+#define Py_CONSTANT_ZERO 5
+#define Py_CONSTANT_ONE 6
+#define Py_CONSTANT_EMPTY_STR 7
+#define Py_CONSTANT_EMPTY_BYTES 8
+#define Py_CONSTANT_EMPTY_TUPLE 9
+
+static inline PyObject* Py_GetConstant(unsigned int constant_id)
+{
+    static PyObject* constants[Py_CONSTANT_EMPTY_TUPLE + 1] = {NULL};
+
+    if (constants[Py_CONSTANT_NONE] == NULL) {
+        constants[Py_CONSTANT_NONE] = Py_None;
+        constants[Py_CONSTANT_FALSE] = Py_False;
+        constants[Py_CONSTANT_TRUE] = Py_True;
+        constants[Py_CONSTANT_ELLIPSIS] = Py_Ellipsis;
+        constants[Py_CONSTANT_NOT_IMPLEMENTED] = Py_NotImplemented;
+
+        constants[Py_CONSTANT_ZERO] = PyLong_FromLong(0);
+        if (constants[Py_CONSTANT_ZERO] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_ONE] = PyLong_FromLong(1);
+        if (constants[Py_CONSTANT_ONE] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_STR] = PyUnicode_FromStringAndSize("", 0);
+        if (constants[Py_CONSTANT_EMPTY_STR] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_BYTES] = PyBytes_FromStringAndSize("", 0);
+        if (constants[Py_CONSTANT_EMPTY_BYTES] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_TUPLE] = PyTuple_New(0);
+        if (constants[Py_CONSTANT_EMPTY_TUPLE] == NULL) {
+            goto fatal_error;
+        }
+        // goto dance to avoid compiler warnings about Py_FatalError()
+        goto init_done;
+
+fatal_error:
+        // This case should never happen
+        Py_FatalError("Py_GetConstant() failed to get constants");
+    }
+
+init_done:
+    if (constant_id <= Py_CONSTANT_EMPTY_TUPLE) {
+        return Py_NewRef(constants[constant_id]);
+    }
+    else {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+}
+
+static inline PyObject* Py_GetConstantBorrowed(unsigned int constant_id)
+{
+    PyObject *obj = Py_GetConstant(constant_id);
+    Py_XDECREF(obj);
+    return obj;
+}
+#endif
+
+
+// gh-114329 added PyList_GetItemRef() to Python 3.13.0a4
+#if PY_VERSION_HEX < 0x030D00A4
+static inline PyObject *
+PyList_GetItemRef(PyObject *op, Py_ssize_t index)
+{
+    PyObject *item = PyList_GetItem(op, index);
+    Py_XINCREF(item);
+    return item;
+}
+#endif
+
+
+// gh-114329 added PyList_GetItemRef() to Python 3.13.0a4
+#if PY_VERSION_HEX < 0x030D00A4
+static inline int
+PyDict_SetDefaultRef(PyObject *d, PyObject *key, PyObject *default_value,
+                     PyObject **result)
+{
+    PyObject *value;
+    if (PyDict_GetItemRef(d, key, &value) < 0) {
+        // get error
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+    if (value != NULL) {
+        // present
+        if (result) {
+            *result = value;
+        }
+        else {
+            Py_DECREF(value);
+        }
+        return 1;
+    }
+
+    // missing: set the item
+    if (PyDict_SetItem(d, key, default_value) < 0) {
+        // set error
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+    if (result) {
+        *result = Py_NewRef(default_value);
+    }
+    return 0;
+}
+#endif
+
+#if PY_VERSION_HEX < 0x030D00B3
+#  define Py_BEGIN_CRITICAL_SECTION(op) {
+#  define Py_END_CRITICAL_SECTION() }
+#  define Py_BEGIN_CRITICAL_SECTION2(a, b) {
+#  define Py_END_CRITICAL_SECTION2() }
+#endif
+
+#if PY_VERSION_HEX < 0x030E0000 && PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION)
+typedef struct PyUnicodeWriter PyUnicodeWriter;
+
+static inline void PyUnicodeWriter_Discard(PyUnicodeWriter *writer)
+{
+    _PyUnicodeWriter_Dealloc((_PyUnicodeWriter*)writer);
+    PyMem_Free(writer);
+}
+
+static inline PyUnicodeWriter* PyUnicodeWriter_Create(Py_ssize_t length)
+{
+    if (length < 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "length must be positive");
+        return NULL;
+    }
+
+    const size_t size = sizeof(_PyUnicodeWriter);
+    PyUnicodeWriter *pub_writer = (PyUnicodeWriter *)PyMem_Malloc(size);
+    if (pub_writer == _Py_NULL) {
+        PyErr_NoMemory();
+        return _Py_NULL;
+    }
+    _PyUnicodeWriter *writer = (_PyUnicodeWriter *)pub_writer;
+
+    _PyUnicodeWriter_Init(writer);
+    if (_PyUnicodeWriter_Prepare(writer, length, 127) < 0) {
+        PyUnicodeWriter_Discard(pub_writer);
+        return NULL;
+    }
+    writer->overallocate = 1;
+    return pub_writer;
+}
+
+static inline PyObject* PyUnicodeWriter_Finish(PyUnicodeWriter *writer)
+{
+    PyObject *str = _PyUnicodeWriter_Finish((_PyUnicodeWriter*)writer);
+    assert(((_PyUnicodeWriter*)writer)->buffer == NULL);
+    PyMem_Free(writer);
+    return str;
+}
+
+static inline int
+PyUnicodeWriter_WriteChar(PyUnicodeWriter *writer, Py_UCS4 ch)
+{
+    if (ch > 0x10ffff) {
+        PyErr_SetString(PyExc_ValueError,
+                        "character must be in range(0x110000)");
+        return -1;
+    }
+
+    return _PyUnicodeWriter_WriteChar((_PyUnicodeWriter*)writer, ch);
+}
+
+static inline int
+PyUnicodeWriter_WriteStr(PyUnicodeWriter *writer, PyObject *obj)
+{
+    PyObject *str = PyObject_Str(obj);
+    if (str == NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteRepr(PyUnicodeWriter *writer, PyObject *obj)
+{
+    PyObject *str = PyObject_Repr(obj);
+    if (str == NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteUTF8(PyUnicodeWriter *writer,
+                          const char *str, Py_ssize_t size)
+{
+    if (size < 0) {
+        size = (Py_ssize_t)strlen(str);
+    }
+
+    PyObject *str_obj = PyUnicode_FromStringAndSize(str, size);
+    if (str_obj == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str_obj);
+    Py_DECREF(str_obj);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteWideChar(PyUnicodeWriter *writer,
+                              const wchar_t *str, Py_ssize_t size)
+{
+    if (size < 0) {
+        size = (Py_ssize_t)wcslen(str);
+    }
+
+    PyObject *str_obj = PyUnicode_FromWideChar(str, size);
+    if (str_obj == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str_obj);
+    Py_DECREF(str_obj);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteSubstring(PyUnicodeWriter *writer, PyObject *str,
+                               Py_ssize_t start, Py_ssize_t end)
+{
+    if (!PyUnicode_Check(str)) {
+        PyErr_Format(PyExc_TypeError, "expect str, not %T", str);
+        return -1;
+    }
+    if (start < 0 || start > end) {
+        PyErr_Format(PyExc_ValueError, "invalid start argument");
+        return -1;
+    }
+    if (end > PyUnicode_GET_LENGTH(str)) {
+        PyErr_Format(PyExc_ValueError, "invalid end argument");
+        return -1;
+    }
+
+    return _PyUnicodeWriter_WriteSubstring((_PyUnicodeWriter*)writer, str,
+                                           start, end);
+}
+
+static inline int
+PyUnicodeWriter_Format(PyUnicodeWriter *writer, const char *format, ...)
+{
+    va_list vargs;
+    va_start(vargs, format);
+    PyObject *str = PyUnicode_FromFormatV(format, vargs);
+    va_end(vargs);
+    if (str == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+#endif  // PY_VERSION_HEX < 0x030E0000
+
+// gh-116560 added PyLong_GetSign() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyLong_GetSign(PyObject *obj, int *sign)
+{
+    if (!PyLong_Check(obj)) {
+        PyErr_Format(PyExc_TypeError, "expect int, got %s", Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+
+    *sign = _PyLong_Sign(obj);
+    return 0;
+}
+#endif
+
+
+// gh-124502 added PyUnicode_Equal() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyUnicode_Equal(PyObject *str1, PyObject *str2)
+{
+    if (!PyUnicode_Check(str1)) {
+        PyErr_Format(PyExc_TypeError, "first argument must be str, not %s",
+                     Py_TYPE(str1)->tp_name);
+        return -1;
+    }
+    if (!PyUnicode_Check(str2)) {
+        PyErr_Format(PyExc_TypeError, "second argument must be str, not %s",
+                     Py_TYPE(str2)->tp_name);
+        return -1;
+    }
+
+#if PY_VERSION_HEX >= 0x030d0000 && !defined(PYPY_VERSION)
+    PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *str1, PyObject *str2);
+
+    return _PyUnicode_Equal(str1, str2);
+#elif PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION)
+    return _PyUnicode_EQ(str1, str2);
+#elif PY_VERSION_HEX >= 0x03090000 && defined(PYPY_VERSION)
+    return _PyUnicode_EQ(str1, str2);
+#else
+    return (PyUnicode_Compare(str1, str2) == 0);
+#endif
+}
+#endif
+
+
+// gh-121645 added PyBytes_Join() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline PyObject* PyBytes_Join(PyObject *sep, PyObject *iterable)
+{
+    return _PyBytes_Join(sep, iterable);
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline Py_hash_t Py_HashBuffer(const void *ptr, Py_ssize_t len)
+{
+#if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
+    PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void *src, Py_ssize_t len);
+
+    return _Py_HashBytes(ptr, len);
+#else
+    Py_hash_t hash;
+    PyObject *bytes = PyBytes_FromStringAndSize((const char*)ptr, len);
+    if (bytes == NULL) {
+        return -1;
+    }
+    hash = PyObject_Hash(bytes);
+    Py_DECREF(bytes);
+    return hash;
+#endif
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyIter_NextItem(PyObject *iter, PyObject **item)
+{
+    iternextfunc tp_iternext;
+
+    assert(iter != NULL);
+    assert(item != NULL);
+
+    tp_iternext = Py_TYPE(iter)->tp_iternext;
+    if (tp_iternext == NULL) {
+        *item = NULL;
+        PyErr_Format(PyExc_TypeError, "expected an iterator, got '%s'",
+                     Py_TYPE(iter)->tp_name);
+        return -1;
+    }
+
+    if ((*item = tp_iternext(iter))) {
+        return 1;
+    }
+    if (!PyErr_Occurred()) {
+        return 0;
+    }
+    if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+        PyErr_Clear();
+        return 0;
+    }
+    return -1;
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline PyObject* PyLong_FromInt32(int32_t value)
+{
+    Py_BUILD_ASSERT(sizeof(long) >= 4);
+    return PyLong_FromLong(value);
+}
+
+static inline PyObject* PyLong_FromInt64(int64_t value)
+{
+    Py_BUILD_ASSERT(sizeof(long long) >= 8);
+    return PyLong_FromLongLong(value);
+}
+
+static inline PyObject* PyLong_FromUInt32(uint32_t value)
+{
+    Py_BUILD_ASSERT(sizeof(unsigned long) >= 4);
+    return PyLong_FromUnsignedLong(value);
+}
+
+static inline PyObject* PyLong_FromUInt64(uint64_t value)
+{
+    Py_BUILD_ASSERT(sizeof(unsigned long long) >= 8);
+    return PyLong_FromUnsignedLongLong(value);
+}
+
+static inline int PyLong_AsInt32(PyObject *obj, int32_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(int) == 4);
+    int value = PyLong_AsInt(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (int32_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsInt64(PyObject *obj, int64_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long long) == 8);
+    long long value = PyLong_AsLongLong(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (int64_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsUInt32(PyObject *obj, uint32_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long) >= 4);
+    unsigned long value = PyLong_AsUnsignedLong(obj);
+    if (value == (unsigned long)-1 && PyErr_Occurred()) {
+        return -1;
+    }
+#if SIZEOF_LONG > 4
+    if ((unsigned long)UINT32_MAX < value) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "Python int too large to convert to C uint32_t");
+        return -1;
+    }
+#endif
+    *pvalue = (uint32_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsUInt64(PyObject *obj, uint64_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long long) == 8);
+    unsigned long long value = PyLong_AsUnsignedLongLong(obj);
+    if (value == (unsigned long long)-1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (uint64_t)value;
+    return 0;
+}
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // PYTHONCAPI_COMPAT

Places

File py313.patch of Package python-numba (Revision 27da4a8d69b219a464b17f39401fd4ac)

Places