From 97e49d644fd3995214c850cc9abe384f99b13abe Mon Sep 17 00:00:00 2001 From: Alex Date: Sun, 27 Jul 2025 14:28:57 +0300 Subject: [PATCH 1/2] Initial support for Python 3.14 --- CMakeLists.txt | 1 + bytecode.cpp | 2 + bytecode_ops.inl | 102 +++++++++++++++++++++++++++++++++++++++++++++++ pyc_module.cpp | 8 +++- pyc_module.h | 1 + 5 files changed, 113 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 476c964..30d9c62 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -62,6 +62,7 @@ add_library(pycxx STATIC bytes/python_3_11.cpp bytes/python_3_12.cpp bytes/python_3_13.cpp + bytes/python_3_14.cpp ) add_executable(pycdas pycdas.cpp) diff --git a/bytecode.cpp b/bytecode.cpp index c6b7cba..4fea737 100644 --- a/bytecode.cpp +++ b/bytecode.cpp @@ -39,6 +39,7 @@ DECLARE_PYTHON(3, 10) DECLARE_PYTHON(3, 11) DECLARE_PYTHON(3, 12) DECLARE_PYTHON(3, 13) +DECLARE_PYTHON(3, 14) const char* Pyc::OpcodeName(int opcode) { @@ -109,6 +110,7 @@ int Pyc::ByteToOpcode(int maj, int min, int opcode) case 11: return python_3_11_map(opcode); case 12: return python_3_12_map(opcode); case 13: return python_3_13_map(opcode); + case 14: return python_3_14_map(opcode); } break; } diff --git a/bytecode_ops.inl b/bytecode_ops.inl index 5cc49c2..5eca64a 100644 --- a/bytecode_ops.inl +++ b/bytecode_ops.inl @@ -124,6 +124,104 @@ OPCODE(FORMAT_WITH_SPEC) // Python 3.13 -> OPCODE(MAKE_FUNCTION) // Python 3.13 -> OPCODE(TO_BOOL) // Python 3.13 -> +OPCODE(BUILD_TEMPLATE) // Python 3.14 -> +OPCODE(BINARY_OP_INPLACE_ADD_UNICODE) +OPCODE(NOT_TAKEN) +OPCODE(POP_ITER) +OPCODE(BUILD_INTERPOLATION) +OPCODE(LOAD_COMMON_CONSTANT) +OPCODE(LOAD_FAST_BORROW) +OPCODE(LOAD_FAST_BORROW_LOAD_FAST_BORROW) +OPCODE(LOAD_SPECIAL) +OPCODE(BINARY_OP_ADD_FLOAT) +OPCODE(BINARY_OP_ADD_INT) +OPCODE(BINARY_OP_ADD_UNICODE) +OPCODE(BINARY_OP_EXTEND) +OPCODE(BINARY_OP_MULTIPLY_FLOAT) +OPCODE(BINARY_OP_MULTIPLY_INT) +OPCODE(BINARY_OP_SUBSCR_DICT) +OPCODE(BINARY_OP_SUBSCR_GETITEM) +OPCODE(BINARY_OP_SUBSCR_LIST_INT) +OPCODE(BINARY_OP_SUBSCR_LIST_SLICE) +OPCODE(BINARY_OP_SUBSCR_STR_INT) +OPCODE(BINARY_OP_SUBSCR_TUPLE_INT) +OPCODE(BINARY_OP_SUBTRACT_FLOAT) +OPCODE(BINARY_OP_SUBTRACT_INT) +OPCODE(CALL_ALLOC_AND_ENTER_INIT) +OPCODE(CALL_BOUND_METHOD_EXACT_ARGS) +OPCODE(CALL_BOUND_METHOD_GENERAL) +OPCODE(CALL_BUILTIN_CLASS) +OPCODE(CALL_BUILTIN_FAST) +OPCODE(CALL_BUILTIN_FAST_WITH_KEYWORDS) +OPCODE(CALL_BUILTIN_O) +OPCODE(CALL_ISINSTANCE) +OPCODE(CALL_KW_BOUND_METHOD) +OPCODE(CALL_KW_NON_PY) +OPCODE(CALL_KW_PY) +OPCODE(CALL_LEN) +OPCODE(CALL_LIST_APPEND) +OPCODE(CALL_METHOD_DESCRIPTOR_FAST) +OPCODE(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS) +OPCODE(CALL_METHOD_DESCRIPTOR_NOARGS) +OPCODE(CALL_METHOD_DESCRIPTOR_O) +OPCODE(CALL_NON_PY_GENERAL) +OPCODE(CALL_PY_EXACT_ARGS) +OPCODE(CALL_PY_GENERAL) +OPCODE(CALL_STR_1) +OPCODE(CALL_TUPLE_1) +OPCODE(CALL_TYPE_1) +OPCODE(COMPARE_OP_FLOAT) +OPCODE(COMPARE_OP_INT) +OPCODE(COMPARE_OP_STR) +OPCODE(CONTAINS_OP_DICT) +OPCODE(CONTAINS_OP_SET) +OPCODE(FOR_ITER_GEN) +OPCODE(FOR_ITER_LIST) +OPCODE(FOR_ITER_RANGE) +OPCODE(FOR_ITER_TUPLE) +OPCODE(JUMP_BACKWARD_JIT) +OPCODE(JUMP_BACKWARD_NO_JIT) +OPCODE(LOAD_ATTR_CLASS) +OPCODE(LOAD_ATTR_CLASS_WITH_METACLASS_CHECK) +OPCODE(LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN) +OPCODE(LOAD_ATTR_INSTANCE_VALUE) +OPCODE(LOAD_ATTR_METHOD_LAZY_DICT) +OPCODE(LOAD_ATTR_METHOD_NO_DICT) +OPCODE(LOAD_ATTR_METHOD_WITH_VALUES) +OPCODE(LOAD_ATTR_MODULE) +OPCODE(LOAD_ATTR_NONDESCRIPTOR_NO_DICT) +OPCODE(LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES) +OPCODE(LOAD_ATTR_PROPERTY) +OPCODE(LOAD_ATTR_SLOT) +OPCODE(LOAD_ATTR_WITH_HINT) +OPCODE(LOAD_CONST_IMMORTAL) +OPCODE(LOAD_CONST_MORTAL) +OPCODE(LOAD_GLOBAL_BUILTIN) +OPCODE(LOAD_GLOBAL_MODULE) +OPCODE(LOAD_SUPER_ATTR_ATTR) +OPCODE(LOAD_SUPER_ATTR_METHOD) +OPCODE(RESUME_CHECK) +OPCODE(SEND_GEN) +OPCODE(STORE_ATTR_INSTANCE_VALUE) +OPCODE(STORE_ATTR_SLOT) +OPCODE(STORE_ATTR_WITH_HINT) +OPCODE(STORE_SUBSCR_DICT) +OPCODE(STORE_SUBSCR_LIST_INT) +OPCODE(TO_BOOL_ALWAYS_TRUE) +OPCODE(TO_BOOL_BOOL) +OPCODE(TO_BOOL_INT) +OPCODE(TO_BOOL_LIST) +OPCODE(TO_BOOL_NONE) +OPCODE(TO_BOOL_STR) +OPCODE(UNPACK_SEQUENCE_LIST) +OPCODE(UNPACK_SEQUENCE_TUPLE) +OPCODE(UNPACK_SEQUENCE_TWO_TUPLE) +OPCODE(ANNOTATIONS_PLACEHOLDER) +OPCODE(JUMP) +OPCODE(JUMP_NO_INTERRUPT) +OPCODE(SETUP_CLEANUP) +OPCODE(STORE_FAST_MAYBE_NULL) + /* Has parameter word */ OPCODE_A_FIRST(STORE_NAME) // Python 1.0 -> names[A] OPCODE_A(DELETE_NAME) // Python 1.0 -> names[A] @@ -269,6 +367,7 @@ OPCODE_A(LOAD_FAST_LOAD_FAST) // Python 3.13 -> A=locals OPCODE_A(SET_FUNCTION_ATTRIBUTE) // Python 3.13 -> A=attribute_type OPCODE_A(STORE_FAST_LOAD_FAST) // Python 3.13 -> A=locals[A<<4]+locals[A&0xf] OPCODE_A(STORE_FAST_STORE_FAST) // Python 3.13 -> A=locals[A<<4]+locals[A&0xf] +OPCODE_A(LOAD_SMALL_INT) // Python 3.14 -> A=small int range(256) /* Instrumented opcodes */ OPCODE_A(INSTRUMENTED_LOAD_SUPER_ATTR) // Python 3.12 -> (see LOAD_SUPER_ATTR) @@ -290,3 +389,6 @@ OPCODE_A(INSTRUMENTED_END_SEND) // Python 3.12 -> (see END OPCODE_A(INSTRUMENTED_INSTRUCTION) // Python 3.12 -> A=(unused) OPCODE_A(INSTRUMENTED_LINE) // Python 3.12 -> ??? OPCODE_A(INSTRUMENTED_CALL_KW) // Python 3.13 -> (see CALL_KW) +OPCODE_A(INSTRUMENTED_POP_ITER) // Python 3.14 -> (see POP_ITER) +OPCODE_A(INSTRUMENTED_NOT_TAKEN) // Python 3.14 -> (see NOT_TAKEN) +OPCODE_A(INSTRUMENTED_END_ASYNC_FOR) // Python 3.14 -> (see END_ASYNC_FOR) diff --git a/pyc_module.cpp b/pyc_module.cpp index 98eecff..9ddd4c9 100644 --- a/pyc_module.cpp +++ b/pyc_module.cpp @@ -182,6 +182,12 @@ void PycModule::setVersion(unsigned int magic) m_unicode = true; break; + case MAGIC_3_14: + m_maj = 3; + m_min = 14; + m_unicode = true; + break; + /* Bad Magic detected */ default: m_maj = -1; @@ -197,7 +203,7 @@ bool PycModule::isSupportedVersion(int major, int minor) case 2: return (minor >= 0 && minor <= 7); case 3: - return (minor >= 0 && minor <= 12); + return (minor >= 0 && minor <= 14); default: return false; } diff --git a/pyc_module.h b/pyc_module.h index 695f4ba..dbdd2a5 100644 --- a/pyc_module.h +++ b/pyc_module.h @@ -36,6 +36,7 @@ enum PycMagic { MAGIC_3_11 = 0x0A0D0DA7, MAGIC_3_12 = 0x0A0D0DCB, MAGIC_3_13 = 0x0A0D0DF3, + MAGIC_3_14 = 0x0A0D0E29, INVALID = 0, }; From 1d1237228aa92c61694958cdf5047d3c18c25343 Mon Sep 17 00:00:00 2001 From: Alex Date: Sun, 27 Jul 2025 14:46:12 +0300 Subject: [PATCH 2/2] Add missed python 3.14 cpp module --- bytes/python_3_14.cpp | 242 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 242 insertions(+) create mode 100644 bytes/python_3_14.cpp diff --git a/bytes/python_3_14.cpp b/bytes/python_3_14.cpp new file mode 100644 index 0000000..4793773 --- /dev/null +++ b/bytes/python_3_14.cpp @@ -0,0 +1,242 @@ +#include "bytecode_map.h" + +BEGIN_MAP(3, 14) + MAP_OP(0, CACHE) + MAP_OP(1, BINARY_SLICE) + MAP_OP(2, BUILD_TEMPLATE) + MAP_OP(3, BINARY_OP_INPLACE_ADD_UNICODE) + MAP_OP(4, CALL_FUNCTION_EX_A) + MAP_OP(5, CHECK_EG_MATCH) + MAP_OP(6, CHECK_EXC_MATCH) + MAP_OP(7, CLEANUP_THROW) + MAP_OP(8, DELETE_SUBSCR) + MAP_OP(9, END_FOR) + MAP_OP(10, END_SEND) + MAP_OP(11, EXIT_INIT_CHECK) + MAP_OP(12, FORMAT_SIMPLE) + MAP_OP(13, FORMAT_WITH_SPEC) + MAP_OP(14, GET_AITER) + MAP_OP(15, GET_ANEXT) + MAP_OP(16, GET_ITER) + MAP_OP(17, RESERVED) + MAP_OP(18, GET_LEN) + MAP_OP(19, GET_YIELD_FROM_ITER) + MAP_OP(20, INTERPRETER_EXIT) + MAP_OP(21, LOAD_BUILD_CLASS) + MAP_OP(22, LOAD_LOCALS) + MAP_OP(23, MAKE_FUNCTION) + MAP_OP(24, MATCH_KEYS) + MAP_OP(25, MATCH_MAPPING) + MAP_OP(26, MATCH_SEQUENCE) + MAP_OP(27, NOP) + MAP_OP(28, NOT_TAKEN) + MAP_OP(29, POP_EXCEPT) + MAP_OP(30, POP_ITER) + MAP_OP(31, POP_TOP) + MAP_OP(32, PUSH_EXC_INFO) + MAP_OP(33, PUSH_NULL) + MAP_OP(34, RETURN_GENERATOR) + MAP_OP(35, RETURN_VALUE) + MAP_OP(36, SETUP_ANNOTATIONS) + MAP_OP(37, STORE_SLICE) + MAP_OP(38, STORE_SUBSCR) + MAP_OP(39, TO_BOOL) + MAP_OP(40, UNARY_INVERT) + MAP_OP(41, UNARY_NEGATIVE) + MAP_OP(42, UNARY_NOT) + MAP_OP(43, WITH_EXCEPT_START) + MAP_OP(44, BINARY_OP_A) + MAP_OP(45, BUILD_INTERPOLATION) + MAP_OP(46, BUILD_LIST_A) + MAP_OP(47, BUILD_MAP_A) + MAP_OP(48, BUILD_SET_A) + MAP_OP(49, BUILD_SLICE_A) + MAP_OP(50, BUILD_STRING_A) + MAP_OP(51, BUILD_TUPLE_A) + MAP_OP(52, CALL_A) + MAP_OP(53, CALL_INTRINSIC_1_A) + MAP_OP(54, CALL_INTRINSIC_2_A) + MAP_OP(55, CALL_KW_A) + MAP_OP(56, COMPARE_OP_A) + MAP_OP(57, CONTAINS_OP_A) + MAP_OP(58, CONVERT_VALUE_A) + MAP_OP(59, COPY_A) + MAP_OP(60, COPY_FREE_VARS_A) + MAP_OP(61, DELETE_ATTR_A) + MAP_OP(62, DELETE_DEREF_A) + MAP_OP(63, DELETE_FAST_A) + MAP_OP(64, DELETE_GLOBAL_A) + MAP_OP(65, DELETE_NAME_A) + MAP_OP(66, DICT_MERGE_A) + MAP_OP(67, DICT_UPDATE_A) + MAP_OP(68, END_ASYNC_FOR) + MAP_OP(69, EXTENDED_ARG_A) + MAP_OP(70, FOR_ITER_A) + MAP_OP(71, GET_AWAITABLE_A) + MAP_OP(72, IMPORT_FROM_A) + MAP_OP(73, IMPORT_NAME_A) + MAP_OP(74, IS_OP_A) + MAP_OP(75, JUMP_BACKWARD_A) + MAP_OP(76, JUMP_BACKWARD_NO_INTERRUPT_A) + MAP_OP(77, JUMP_FORWARD_A) + MAP_OP(78, LIST_APPEND) + MAP_OP(79, LIST_EXTEND_A) + MAP_OP(80, LOAD_ATTR_A) + MAP_OP(81, LOAD_COMMON_CONSTANT) + MAP_OP(82, LOAD_CONST_A) + MAP_OP(83, LOAD_DEREF_A) + MAP_OP(84, LOAD_FAST_A) + MAP_OP(85, LOAD_FAST_AND_CLEAR_A) + MAP_OP(86, LOAD_FAST_BORROW) + MAP_OP(87, LOAD_FAST_BORROW_LOAD_FAST_BORROW) + MAP_OP(88, LOAD_FAST_CHECK_A) + MAP_OP(89, LOAD_FAST_LOAD_FAST_A) + MAP_OP(90, LOAD_FROM_DICT_OR_DEREF_A) + MAP_OP(91, LOAD_FROM_DICT_OR_GLOBALS_A) + MAP_OP(92, LOAD_GLOBAL_A) + MAP_OP(93, LOAD_NAME_A) + MAP_OP(94, LOAD_SMALL_INT_A) + MAP_OP(95, LOAD_SPECIAL) + MAP_OP(96, LOAD_SUPER_ATTR_A) + MAP_OP(97, MAKE_CELL_A) + MAP_OP(98, MAP_ADD_A) + MAP_OP(99, MATCH_CLASS_A) + MAP_OP(100, POP_JUMP_IF_FALSE_A) + MAP_OP(101, POP_JUMP_IF_NONE_A) + MAP_OP(102, POP_JUMP_IF_NOT_NONE_A) + MAP_OP(103, POP_JUMP_IF_TRUE_A) + MAP_OP(104, RAISE_VARARGS_A) + MAP_OP(105, RERAISE) + MAP_OP(106, SEND_A) + MAP_OP(107, SET_ADD) + MAP_OP(108, SET_FUNCTION_ATTRIBUTE_A) + MAP_OP(109, SET_UPDATE_A) + MAP_OP(110, STORE_ATTR_A) + MAP_OP(111, STORE_DEREF_A) + MAP_OP(112, STORE_FAST_A) + MAP_OP(113, STORE_FAST_LOAD_FAST_A) + MAP_OP(114, STORE_FAST_STORE_FAST_A) + MAP_OP(115, STORE_GLOBAL_A) + MAP_OP(116, STORE_NAME_A) + MAP_OP(117, SWAP_A) + MAP_OP(118, UNPACK_EX_A) + MAP_OP(119, UNPACK_SEQUENCE_A) + MAP_OP(120, YIELD_VALUE_A) + MAP_OP(128, RESUME_A) + MAP_OP(129, BINARY_OP_ADD_FLOAT) + MAP_OP(130, BINARY_OP_ADD_INT) + MAP_OP(131, BINARY_OP_ADD_UNICODE) + MAP_OP(132, BINARY_OP_EXTEND) + MAP_OP(133, BINARY_OP_MULTIPLY_FLOAT) + MAP_OP(134, BINARY_OP_MULTIPLY_INT) + MAP_OP(135, BINARY_OP_SUBSCR_DICT) + MAP_OP(136, BINARY_OP_SUBSCR_GETITEM) + MAP_OP(137, BINARY_OP_SUBSCR_LIST_INT) + MAP_OP(138, BINARY_OP_SUBSCR_LIST_SLICE) + MAP_OP(139, BINARY_OP_SUBSCR_STR_INT) + MAP_OP(140, BINARY_OP_SUBSCR_TUPLE_INT) + MAP_OP(141, BINARY_OP_SUBTRACT_FLOAT) + MAP_OP(142, BINARY_OP_SUBTRACT_INT) + MAP_OP(143, CALL_ALLOC_AND_ENTER_INIT) + MAP_OP(144, CALL_BOUND_METHOD_EXACT_ARGS) + MAP_OP(145, CALL_BOUND_METHOD_GENERAL) + MAP_OP(146, CALL_BUILTIN_CLASS) + MAP_OP(147, CALL_BUILTIN_FAST) + MAP_OP(148, CALL_BUILTIN_FAST_WITH_KEYWORDS) + MAP_OP(149, CALL_BUILTIN_O) + MAP_OP(150, CALL_ISINSTANCE) + MAP_OP(151, CALL_KW_BOUND_METHOD) + MAP_OP(152, CALL_KW_NON_PY) + MAP_OP(153, CALL_KW_PY) + MAP_OP(154, CALL_LEN) + MAP_OP(155, CALL_LIST_APPEND) + MAP_OP(156, CALL_METHOD_DESCRIPTOR_FAST) + MAP_OP(157, CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS) + MAP_OP(158, CALL_METHOD_DESCRIPTOR_NOARGS) + MAP_OP(159, CALL_METHOD_DESCRIPTOR_O) + MAP_OP(160, CALL_NON_PY_GENERAL) + MAP_OP(161, CALL_PY_EXACT_ARGS) + MAP_OP(162, CALL_PY_GENERAL) + MAP_OP(163, CALL_STR_1) + MAP_OP(164, CALL_TUPLE_1) + MAP_OP(165, CALL_TYPE_1) + MAP_OP(166, COMPARE_OP_FLOAT) + MAP_OP(167, COMPARE_OP_INT) + MAP_OP(168, COMPARE_OP_STR) + MAP_OP(169, CONTAINS_OP_DICT) + MAP_OP(170, CONTAINS_OP_SET) + MAP_OP(171, FOR_ITER_GEN) + MAP_OP(172, FOR_ITER_LIST) + MAP_OP(173, FOR_ITER_RANGE) + MAP_OP(174, FOR_ITER_TUPLE) + MAP_OP(175, JUMP_BACKWARD_JIT) + MAP_OP(176, JUMP_BACKWARD_NO_JIT) + MAP_OP(177, LOAD_ATTR_CLASS) + MAP_OP(178, LOAD_ATTR_CLASS_WITH_METACLASS_CHECK) + MAP_OP(179, LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN) + MAP_OP(180, LOAD_ATTR_INSTANCE_VALUE) + MAP_OP(181, LOAD_ATTR_METHOD_LAZY_DICT) + MAP_OP(182, LOAD_ATTR_METHOD_NO_DICT) + MAP_OP(183, LOAD_ATTR_METHOD_WITH_VALUES) + MAP_OP(184, LOAD_ATTR_MODULE) + MAP_OP(185, LOAD_ATTR_NONDESCRIPTOR_NO_DICT) + MAP_OP(186, LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES) + MAP_OP(187, LOAD_ATTR_PROPERTY) + MAP_OP(188, LOAD_ATTR_SLOT) + MAP_OP(189, LOAD_ATTR_WITH_HINT) + MAP_OP(190, LOAD_CONST_IMMORTAL) + MAP_OP(191, LOAD_CONST_MORTAL) + MAP_OP(192, LOAD_GLOBAL_BUILTIN) + MAP_OP(193, LOAD_GLOBAL_MODULE) + MAP_OP(194, LOAD_SUPER_ATTR_ATTR) + MAP_OP(195, LOAD_SUPER_ATTR_METHOD) + MAP_OP(196, RESUME_CHECK) + MAP_OP(197, SEND_GEN) + MAP_OP(198, STORE_ATTR_INSTANCE_VALUE) + MAP_OP(199, STORE_ATTR_SLOT) + MAP_OP(200, STORE_ATTR_WITH_HINT) + MAP_OP(201, STORE_SUBSCR_DICT) + MAP_OP(202, STORE_SUBSCR_LIST_INT) + MAP_OP(203, TO_BOOL_ALWAYS_TRUE) + MAP_OP(204, TO_BOOL_BOOL) + MAP_OP(205, TO_BOOL_INT) + MAP_OP(206, TO_BOOL_LIST) + MAP_OP(207, TO_BOOL_NONE) + MAP_OP(208, TO_BOOL_STR) + MAP_OP(209, UNPACK_SEQUENCE_LIST) + MAP_OP(210, UNPACK_SEQUENCE_TUPLE) + MAP_OP(211, UNPACK_SEQUENCE_TWO_TUPLE) + MAP_OP(234, INSTRUMENTED_END_FOR_A) + MAP_OP(235, INSTRUMENTED_POP_ITER_A) + MAP_OP(236, INSTRUMENTED_END_SEND_A) + MAP_OP(237, INSTRUMENTED_FOR_ITER_A) + MAP_OP(238, INSTRUMENTED_INSTRUCTION_A) + MAP_OP(239, INSTRUMENTED_JUMP_FORWARD_A) + MAP_OP(240, INSTRUMENTED_NOT_TAKEN_A) + MAP_OP(241, INSTRUMENTED_POP_JUMP_IF_TRUE_A) + MAP_OP(242, INSTRUMENTED_POP_JUMP_IF_FALSE_A) + MAP_OP(243, INSTRUMENTED_POP_JUMP_IF_NONE_A) + MAP_OP(244, INSTRUMENTED_POP_JUMP_IF_NOT_NONE_A) + MAP_OP(245, INSTRUMENTED_RESUME_A) + MAP_OP(246, INSTRUMENTED_RETURN_VALUE_A) + MAP_OP(247, INSTRUMENTED_YIELD_VALUE_A) + MAP_OP(248, INSTRUMENTED_END_ASYNC_FOR_A) + MAP_OP(249, INSTRUMENTED_LOAD_SUPER_ATTR_A) + MAP_OP(250, INSTRUMENTED_CALL_A) + MAP_OP(251, INSTRUMENTED_CALL_KW_A) + MAP_OP(252, INSTRUMENTED_CALL_FUNCTION_EX_A) + MAP_OP(253, INSTRUMENTED_JUMP_BACKWARD_A) + MAP_OP(254, INSTRUMENTED_LINE_A) + MAP_OP(255, ENTER_EXECUTOR_A) + MAP_OP(256, ANNOTATIONS_PLACEHOLDER) + MAP_OP(257, JUMP) + MAP_OP(258, JUMP_IF_FALSE_A) + MAP_OP(259, JUMP_IF_TRUE_A) + MAP_OP(260, JUMP_NO_INTERRUPT) + MAP_OP(261, LOAD_CLOSURE_A) + MAP_OP(262, POP_BLOCK) + MAP_OP(263, SETUP_CLEANUP) + MAP_OP(264, SETUP_FINALLY_A) + MAP_OP(265, SETUP_WITH_A) + MAP_OP(266, STORE_FAST_MAYBE_NULL) +END_MAP()