chore: directory structure

pycdc/bytes/bytecode_map.h

@@ -0,0 +1,14 @@
+#include "bytecode.h"
+
+#define BEGIN_MAP(maj, min) \
+    int python_##maj##_##min##_map(int id) \
+    { \
+        switch (id) {
+
+#define MAP_OP(op, name) \
+        case op: return Pyc::name;
+
+#define END_MAP() \
+        default: return Pyc::PYC_INVALID_OPCODE; \
+        } \
+    }

pycdc/bytes/python_1_0.cpp

@@ -0,0 +1,89 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(1, 0)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(14, UNARY_CALL)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_CALL)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, RAISE_EXCEPTION)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, LOAD_GLOBALS)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(86, BUILD_FUNCTION)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_TUPLE_A)
+    MAP_OP(93, UNPACK_LIST_A)
+    MAP_OP(94, UNPACK_ARG_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, UNPACK_VARARG_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(109, ACCESS_MODE_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(115, LOAD_LOCAL_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(123, RESERVE_FAST_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+END_MAP()

pycdc/bytes/python_1_1.cpp

@@ -0,0 +1,90 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(1, 1)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(14, UNARY_CALL)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_CALL)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, RAISE_EXCEPTION)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, LOAD_GLOBALS)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(86, BUILD_FUNCTION)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_TUPLE_A)
+    MAP_OP(93, UNPACK_LIST_A)
+    MAP_OP(94, UNPACK_ARG_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, UNPACK_VARARG_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(109, ACCESS_MODE_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(115, LOAD_LOCAL_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(117, SET_FUNC_ARGS_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(123, RESERVE_FAST_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+END_MAP()

pycdc/bytes/python_1_3.cpp

@@ -0,0 +1,87 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(1, 3)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_TUPLE_A)
+    MAP_OP(93, UNPACK_LIST_A)
+    MAP_OP(94, UNPACK_ARG_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, UNPACK_VARARG_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(109, ACCESS_MODE_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(115, LOAD_LOCAL_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(117, SET_FUNC_ARGS_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+END_MAP()

pycdc/bytes/python_1_4.cpp

@@ -0,0 +1,89 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(1, 4)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_TUPLE_A)
+    MAP_OP(93, UNPACK_LIST_A)
+    MAP_OP(94, UNPACK_ARG_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, UNPACK_VARARG_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(109, ACCESS_MODE_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(115, LOAD_LOCAL_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(117, SET_FUNC_ARGS_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+END_MAP()

pycdc/bytes/python_1_5.cpp

@@ -0,0 +1,84 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(1, 5)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_TUPLE_A)
+    MAP_OP(93, UNPACK_LIST_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+END_MAP()

pycdc/bytes/python_1_6.cpp

@@ -0,0 +1,87 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(1, 6)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_TUPLE_A)
+    MAP_OP(93, UNPACK_LIST_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+END_MAP()

pycdc/bytes/python_2_0.cpp

@@ -0,0 +1,103 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(2, 0)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(58, INPLACE_DIVIDE)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(73, PRINT_ITEM_TO)
+    MAP_OP(74, PRINT_NEWLINE_TO)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+END_MAP()

pycdc/bytes/python_2_1.cpp

@@ -0,0 +1,108 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(2, 1)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(58, INPLACE_DIVIDE)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(73, PRINT_ITEM_TO)
+    MAP_OP(74, PRINT_NEWLINE_TO)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+END_MAP()

pycdc/bytes/python_2_2.cpp

@@ -0,0 +1,115 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(2, 2)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(58, INPLACE_DIVIDE)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(73, PRINT_ITEM_TO)
+    MAP_OP(74, PRINT_NEWLINE_TO)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, FOR_LOOP_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, SET_LINENO_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+END_MAP()

pycdc/bytes/python_2_3.cpp

@@ -0,0 +1,113 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(2, 3)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(58, INPLACE_DIVIDE)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(73, PRINT_ITEM_TO)
+    MAP_OP(74, PRINT_NEWLINE_TO)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+END_MAP()

pycdc/bytes/python_2_4.cpp

@@ -0,0 +1,115 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(2, 4)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(18, LIST_APPEND)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(58, INPLACE_DIVIDE)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(73, PRINT_ITEM_TO)
+    MAP_OP(74, PRINT_NEWLINE_TO)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+END_MAP()

pycdc/bytes/python_2_5.cpp

@@ -0,0 +1,116 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(2, 5)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(18, LIST_APPEND)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(58, INPLACE_DIVIDE)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(73, PRINT_ITEM_TO)
+    MAP_OP(74, PRINT_NEWLINE_TO)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+END_MAP()

pycdc/bytes/python_2_6.cpp

@@ -0,0 +1,117 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(2, 6)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(18, LIST_APPEND)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(54, STORE_MAP)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(58, INPLACE_DIVIDE)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(73, PRINT_ITEM_TO)
+    MAP_OP(74, PRINT_NEWLINE_TO)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_MAP_A)
+    MAP_OP(105, LOAD_ATTR_A)
+    MAP_OP(106, COMPARE_OP_A)
+    MAP_OP(107, IMPORT_NAME_A)
+    MAP_OP(108, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+END_MAP()

pycdc/bytes/python_2_7.cpp

@@ -0,0 +1,123 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(2, 7)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(13, UNARY_CONVERT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(21, BINARY_DIVIDE)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(30, SLICE_0)
+    MAP_OP(31, SLICE_1)
+    MAP_OP(32, SLICE_2)
+    MAP_OP(33, SLICE_3)
+    MAP_OP(40, STORE_SLICE_0)
+    MAP_OP(41, STORE_SLICE_1)
+    MAP_OP(42, STORE_SLICE_2)
+    MAP_OP(43, STORE_SLICE_3)
+    MAP_OP(50, DELETE_SLICE_0)
+    MAP_OP(51, DELETE_SLICE_1)
+    MAP_OP(52, DELETE_SLICE_2)
+    MAP_OP(53, DELETE_SLICE_3)
+    MAP_OP(54, STORE_MAP)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(58, INPLACE_DIVIDE)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, PRINT_ITEM)
+    MAP_OP(72, PRINT_NEWLINE)
+    MAP_OP(73, PRINT_ITEM_TO)
+    MAP_OP(74, PRINT_NEWLINE_TO)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP)
+    MAP_OP(82, LOAD_LOCALS)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, EXEC_STMT)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, BUILD_CLASS)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, LIST_APPEND_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(145, EXTENDED_ARG_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+END_MAP()

pycdc/bytes/python_3_0.cpp

@@ -0,0 +1,101 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 0)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(17, SET_ADD)
+    MAP_OP(18, LIST_APPEND)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(54, STORE_MAP)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, STORE_LOCALS)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_A)
+    MAP_OP(112, JUMP_IF_TRUE_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+END_MAP()

pycdc/bytes/python_3_1.cpp

@@ -0,0 +1,104 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 1)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(54, STORE_MAP)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, STORE_LOCALS)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, DUP_TOPX_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+END_MAP()

pycdc/bytes/python_3_10.cpp

@@ -0,0 +1,131 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 10)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(6, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(16, BINARY_MATRIX_MULTIPLY)
+    MAP_OP(17, INPLACE_MATRIX_MULTIPLY)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(30, GET_LEN)
+    MAP_OP(31, MATCH_MAPPING)
+    MAP_OP(32, MATCH_SEQUENCE)
+    MAP_OP(33, MATCH_KEYS)
+    MAP_OP(34, COPY_DICT_WITHOUT_KEYS)
+    MAP_OP(49, WITH_EXCEPT_START)
+    MAP_OP(50, GET_AITER)
+    MAP_OP(51, GET_ANEXT)
+    MAP_OP(52, BEFORE_ASYNC_WITH)
+    MAP_OP(54, END_ASYNC_FOR)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, GET_YIELD_FROM_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(72, YIELD_FROM)
+    MAP_OP(73, GET_AWAITABLE)
+    MAP_OP(74, LOAD_ASSERTION_ERROR)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(82, LIST_TO_TUPLE)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, SETUP_ANNOTATIONS)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, ROT_N_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(117, IS_OP_A)
+    MAP_OP(118, CONTAINS_OP_A)
+    MAP_OP(119, RERAISE_A)
+    MAP_OP(121, JUMP_IF_NOT_EXC_MATCH_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(129, GEN_START_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_EX_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(148, LOAD_CLASSDEREF_A)
+    MAP_OP(152, MATCH_CLASS_A)
+    MAP_OP(154, SETUP_ASYNC_WITH_A)
+    MAP_OP(155, FORMAT_VALUE_A)
+    MAP_OP(156, BUILD_CONST_KEY_MAP_A)
+    MAP_OP(157, BUILD_STRING_A)
+    MAP_OP(160, LOAD_METHOD_A)
+    MAP_OP(161, CALL_METHOD_A)
+    MAP_OP(162, LIST_EXTEND_A)
+    MAP_OP(163, SET_UPDATE_A)
+    MAP_OP(164, DICT_MERGE_A)
+    MAP_OP(165, DICT_UPDATE_A)
+END_MAP()

pycdc/bytes/python_3_11.cpp

@@ -0,0 +1,114 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 11)
+    MAP_OP(0, CACHE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, PUSH_NULL)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(30, GET_LEN)
+    MAP_OP(31, MATCH_MAPPING)
+    MAP_OP(32, MATCH_SEQUENCE)
+    MAP_OP(33, MATCH_KEYS)
+    MAP_OP(35, PUSH_EXC_INFO)
+    MAP_OP(36, CHECK_EXC_MATCH)
+    MAP_OP(37, CHECK_EG_MATCH)
+    MAP_OP(49, WITH_EXCEPT_START)
+    MAP_OP(50, GET_AITER)
+    MAP_OP(51, GET_ANEXT)
+    MAP_OP(52, BEFORE_ASYNC_WITH)
+    MAP_OP(53, BEFORE_WITH)
+    MAP_OP(54, END_ASYNC_FOR)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, GET_YIELD_FROM_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(74, LOAD_ASSERTION_ERROR)
+    MAP_OP(75, RETURN_GENERATOR)
+    MAP_OP(82, LIST_TO_TUPLE)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, SETUP_ANNOTATIONS)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, ASYNC_GEN_WRAP)
+    MAP_OP(88, PREP_RERAISE_STAR)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, SWAP_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(114, POP_JUMP_FORWARD_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_FORWARD_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(117, IS_OP_A)
+    MAP_OP(118, CONTAINS_OP_A)
+    MAP_OP(119, RERAISE_A)
+    MAP_OP(120, COPY_A)
+    MAP_OP(122, BINARY_OP_A)
+    MAP_OP(123, SEND_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(128, POP_JUMP_FORWARD_IF_NOT_NONE_A)
+    MAP_OP(129, POP_JUMP_FORWARD_IF_NONE_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, GET_AWAITABLE_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, JUMP_BACKWARD_NO_INTERRUPT_A)
+    MAP_OP(135, MAKE_CELL_A)
+    MAP_OP(136, LOAD_CLOSURE_A)
+    MAP_OP(137, LOAD_DEREF_A)
+    MAP_OP(138, STORE_DEREF_A)
+    MAP_OP(139, DELETE_DEREF_A)
+    MAP_OP(140, JUMP_BACKWARD_A)
+    MAP_OP(142, CALL_FUNCTION_EX_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(148, LOAD_CLASSDEREF_A)
+    MAP_OP(149, COPY_FREE_VARS_A)
+    MAP_OP(151, RESUME_A)
+    MAP_OP(152, MATCH_CLASS_A)
+    MAP_OP(155, FORMAT_VALUE_A)
+    MAP_OP(156, BUILD_CONST_KEY_MAP_A)
+    MAP_OP(157, BUILD_STRING_A)
+    MAP_OP(160, LOAD_METHOD_A)
+    MAP_OP(162, LIST_EXTEND_A)
+    MAP_OP(163, SET_UPDATE_A)
+    MAP_OP(164, DICT_MERGE_A)
+    MAP_OP(165, DICT_UPDATE_A)
+    MAP_OP(166, PRECALL_A)
+    MAP_OP(171, CALL_A)
+    MAP_OP(172, KW_NAMES_A)
+    MAP_OP(173, POP_JUMP_BACKWARD_IF_NOT_NONE_A)
+    MAP_OP(174, POP_JUMP_BACKWARD_IF_NONE_A)
+    MAP_OP(175, POP_JUMP_BACKWARD_IF_FALSE_A)
+    MAP_OP(176, POP_JUMP_BACKWARD_IF_TRUE_A)
+END_MAP()

pycdc/bytes/python_3_12.cpp

@@ -0,0 +1,133 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 12)
+    MAP_OP(0, CACHE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, PUSH_NULL)
+    MAP_OP(3, INTERPRETER_EXIT)
+    MAP_OP(4, END_FOR)
+    MAP_OP(5, END_SEND)
+    MAP_OP(9, NOP)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(17, RESERVED)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_SLICE)
+    MAP_OP(27, STORE_SLICE)
+    MAP_OP(30, GET_LEN)
+    MAP_OP(31, MATCH_MAPPING)
+    MAP_OP(32, MATCH_SEQUENCE)
+    MAP_OP(33, MATCH_KEYS)
+    MAP_OP(35, PUSH_EXC_INFO)
+    MAP_OP(36, CHECK_EXC_MATCH)
+    MAP_OP(37, CHECK_EG_MATCH)
+    MAP_OP(49, WITH_EXCEPT_START)
+    MAP_OP(50, GET_AITER)
+    MAP_OP(51, GET_ANEXT)
+    MAP_OP(52, BEFORE_ASYNC_WITH)
+    MAP_OP(53, BEFORE_WITH)
+    MAP_OP(54, END_ASYNC_FOR)
+    MAP_OP(55, CLEANUP_THROW)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, GET_YIELD_FROM_ITER)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(74, LOAD_ASSERTION_ERROR)
+    MAP_OP(75, RETURN_GENERATOR)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(85, SETUP_ANNOTATIONS)
+    MAP_OP(87, LOAD_LOCALS)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(99, SWAP_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(117, IS_OP_A)
+    MAP_OP(118, CONTAINS_OP_A)
+    MAP_OP(119, RERAISE_A)
+    MAP_OP(120, COPY_A)
+    MAP_OP(121, RETURN_CONST_A)
+    MAP_OP(122, BINARY_OP_A)
+    MAP_OP(123, SEND_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, LOAD_FAST_CHECK_A)
+    MAP_OP(128, POP_JUMP_IF_NOT_NONE_A)
+    MAP_OP(129, POP_JUMP_IF_NONE_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, GET_AWAITABLE_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, JUMP_BACKWARD_NO_INTERRUPT_A)
+    MAP_OP(135, MAKE_CELL_A)
+    MAP_OP(136, LOAD_CLOSURE_A)
+    MAP_OP(137, LOAD_DEREF_A)
+    MAP_OP(138, STORE_DEREF_A)
+    MAP_OP(139, DELETE_DEREF_A)
+    MAP_OP(140, JUMP_BACKWARD_A)
+    MAP_OP(141, LOAD_SUPER_ATTR_A)
+    MAP_OP(142, CALL_FUNCTION_EX_A)
+    MAP_OP(143, LOAD_FAST_AND_CLEAR_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(149, COPY_FREE_VARS_A)
+    MAP_OP(150, YIELD_VALUE_A)
+    MAP_OP(151, RESUME_A)
+    MAP_OP(152, MATCH_CLASS_A)
+    MAP_OP(155, FORMAT_VALUE_A)
+    MAP_OP(156, BUILD_CONST_KEY_MAP_A)
+    MAP_OP(157, BUILD_STRING_A)
+    MAP_OP(162, LIST_EXTEND_A)
+    MAP_OP(163, SET_UPDATE_A)
+    MAP_OP(164, DICT_MERGE_A)
+    MAP_OP(165, DICT_UPDATE_A)
+    MAP_OP(171, CALL_A)
+    MAP_OP(172, KW_NAMES_A)
+    MAP_OP(173, CALL_INTRINSIC_1_A)
+    MAP_OP(174, CALL_INTRINSIC_2_A)
+    MAP_OP(175, LOAD_FROM_DICT_OR_GLOBALS_A)
+    MAP_OP(176, LOAD_FROM_DICT_OR_DEREF_A)
+    MAP_OP(237, INSTRUMENTED_LOAD_SUPER_ATTR_A)
+    MAP_OP(238, INSTRUMENTED_POP_JUMP_IF_NONE_A)
+    MAP_OP(239, INSTRUMENTED_POP_JUMP_IF_NOT_NONE_A)
+    MAP_OP(240, INSTRUMENTED_RESUME_A)
+    MAP_OP(241, INSTRUMENTED_CALL_A)
+    MAP_OP(242, INSTRUMENTED_RETURN_VALUE_A)
+    MAP_OP(243, INSTRUMENTED_YIELD_VALUE_A)
+    MAP_OP(244, INSTRUMENTED_CALL_FUNCTION_EX_A)
+    MAP_OP(245, INSTRUMENTED_JUMP_FORWARD_A)
+    MAP_OP(246, INSTRUMENTED_JUMP_BACKWARD_A)
+    MAP_OP(247, INSTRUMENTED_RETURN_CONST_A)
+    MAP_OP(248, INSTRUMENTED_FOR_ITER_A)
+    MAP_OP(249, INSTRUMENTED_POP_JUMP_IF_FALSE_A)
+    MAP_OP(250, INSTRUMENTED_POP_JUMP_IF_TRUE_A)
+    MAP_OP(251, INSTRUMENTED_END_FOR_A)
+    MAP_OP(252, INSTRUMENTED_END_SEND_A)
+    MAP_OP(253, INSTRUMENTED_INSTRUCTION_A)
+    MAP_OP(254, INSTRUMENTED_LINE_A)
+END_MAP()

pycdc/bytes/python_3_13.cpp

@@ -0,0 +1,142 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 13)
+    MAP_OP(0, CACHE)
+    MAP_OP(1, BEFORE_ASYNC_WITH)
+    MAP_OP(2, BEFORE_WITH)
+    MAP_OP(4, BINARY_SLICE)
+    MAP_OP(5, BINARY_SUBSCR)
+    MAP_OP(6, CHECK_EG_MATCH)
+    MAP_OP(7, CHECK_EXC_MATCH)
+    MAP_OP(8, CLEANUP_THROW)
+    MAP_OP(9, DELETE_SUBSCR)
+    MAP_OP(10, END_ASYNC_FOR)
+    MAP_OP(11, END_FOR)
+    MAP_OP(12, END_SEND)
+    MAP_OP(13, EXIT_INIT_CHECK)
+    MAP_OP(14, FORMAT_SIMPLE)
+    MAP_OP(15, FORMAT_WITH_SPEC)
+    MAP_OP(16, GET_AITER)
+    MAP_OP(17, RESERVED)
+    MAP_OP(18, GET_ANEXT)
+    MAP_OP(19, GET_ITER)
+    MAP_OP(20, GET_LEN)
+    MAP_OP(21, GET_YIELD_FROM_ITER)
+    MAP_OP(22, INTERPRETER_EXIT)
+    MAP_OP(23, LOAD_ASSERTION_ERROR)
+    MAP_OP(24, LOAD_BUILD_CLASS)
+    MAP_OP(25, LOAD_LOCALS)
+    MAP_OP(26, MAKE_FUNCTION)
+    MAP_OP(27, MATCH_KEYS)
+    MAP_OP(28, MATCH_MAPPING)
+    MAP_OP(29, MATCH_SEQUENCE)
+    MAP_OP(30, NOP)
+    MAP_OP(31, POP_EXCEPT)
+    MAP_OP(32, POP_TOP)
+    MAP_OP(33, PUSH_EXC_INFO)
+    MAP_OP(34, PUSH_NULL)
+    MAP_OP(35, RETURN_GENERATOR)
+    MAP_OP(36, RETURN_VALUE)
+    MAP_OP(37, SETUP_ANNOTATIONS)
+    MAP_OP(38, STORE_SLICE)
+    MAP_OP(39, STORE_SUBSCR)
+    MAP_OP(40, TO_BOOL)
+    MAP_OP(41, UNARY_INVERT)
+    MAP_OP(42, UNARY_NEGATIVE)
+    MAP_OP(43, UNARY_NOT)
+    MAP_OP(44, WITH_EXCEPT_START)
+    MAP_OP(45, BINARY_OP_A)
+    MAP_OP(46, BUILD_CONST_KEY_MAP_A)
+    MAP_OP(47, BUILD_LIST_A)
+    MAP_OP(48, BUILD_MAP_A)
+    MAP_OP(49, BUILD_SET_A)
+    MAP_OP(50, BUILD_SLICE_A)
+    MAP_OP(51, BUILD_STRING_A)
+    MAP_OP(52, BUILD_TUPLE_A)
+    MAP_OP(53, CALL_A)
+    MAP_OP(54, CALL_FUNCTION_EX_A)
+    MAP_OP(55, CALL_INTRINSIC_1_A)
+    MAP_OP(56, CALL_INTRINSIC_2_A)
+    MAP_OP(57, CALL_KW_A)
+    MAP_OP(58, COMPARE_OP_A)
+    MAP_OP(59, CONTAINS_OP_A)
+    MAP_OP(60, CONVERT_VALUE_A)
+    MAP_OP(61, COPY_A)
+    MAP_OP(62, COPY_FREE_VARS_A)
+    MAP_OP(63, DELETE_ATTR_A)
+    MAP_OP(64, DELETE_DEREF_A)
+    MAP_OP(65, DELETE_FAST_A)
+    MAP_OP(66, DELETE_GLOBAL_A)
+    MAP_OP(67, DELETE_NAME_A)
+    MAP_OP(68, DICT_MERGE_A)
+    MAP_OP(69, DICT_UPDATE_A)
+    MAP_OP(70, ENTER_EXECUTOR_A)
+    MAP_OP(71, EXTENDED_ARG_A)
+    MAP_OP(72, FOR_ITER_A)
+    MAP_OP(73, GET_AWAITABLE_A)
+    MAP_OP(74, IMPORT_FROM_A)
+    MAP_OP(75, IMPORT_NAME_A)
+    MAP_OP(76, IS_OP_A)
+    MAP_OP(77, JUMP_BACKWARD_A)
+    MAP_OP(78, JUMP_BACKWARD_NO_INTERRUPT_A)
+    MAP_OP(79, JUMP_FORWARD_A)
+    MAP_OP(80, LIST_APPEND_A)
+    MAP_OP(81, LIST_EXTEND_A)
+    MAP_OP(82, LOAD_ATTR_A)
+    MAP_OP(83, LOAD_CONST_A)
+    MAP_OP(84, LOAD_DEREF_A)
+    MAP_OP(85, LOAD_FAST_A)
+    MAP_OP(86, LOAD_FAST_AND_CLEAR_A)
+    MAP_OP(87, LOAD_FAST_CHECK_A)
+    MAP_OP(88, LOAD_FAST_LOAD_FAST_A)
+    MAP_OP(89, LOAD_FROM_DICT_OR_DEREF_A)
+    MAP_OP(90, LOAD_FROM_DICT_OR_GLOBALS_A)
+    MAP_OP(91, LOAD_GLOBAL_A)
+    MAP_OP(92, LOAD_NAME_A)
+    MAP_OP(93, LOAD_SUPER_ATTR_A)
+    MAP_OP(94, MAKE_CELL_A)
+    MAP_OP(95, MAP_ADD_A)
+    MAP_OP(96, MATCH_CLASS_A)
+    MAP_OP(97, POP_JUMP_IF_FALSE_A)
+    MAP_OP(98, POP_JUMP_IF_NONE_A)
+    MAP_OP(99, POP_JUMP_IF_NOT_NONE_A)
+    MAP_OP(100, POP_JUMP_IF_TRUE_A)
+    MAP_OP(101, RAISE_VARARGS_A)
+    MAP_OP(102, RERAISE_A)
+    MAP_OP(103, RETURN_CONST_A)
+    MAP_OP(104, SEND_A)
+    MAP_OP(105, SET_ADD_A)
+    MAP_OP(106, SET_FUNCTION_ATTRIBUTE_A)
+    MAP_OP(107, SET_UPDATE_A)
+    MAP_OP(108, STORE_ATTR_A)
+    MAP_OP(109, STORE_DEREF_A)
+    MAP_OP(110, STORE_FAST_A)
+    MAP_OP(111, STORE_FAST_LOAD_FAST_A)
+    MAP_OP(112, STORE_FAST_STORE_FAST_A)
+    MAP_OP(113, STORE_GLOBAL_A)
+    MAP_OP(114, STORE_NAME_A)
+    MAP_OP(115, SWAP_A)
+    MAP_OP(116, UNPACK_EX_A)
+    MAP_OP(117, UNPACK_SEQUENCE_A)
+    MAP_OP(118, YIELD_VALUE_A)
+    MAP_OP(149, RESUME_A)
+    MAP_OP(236, INSTRUMENTED_RESUME_A)
+    MAP_OP(237, INSTRUMENTED_END_FOR_A)
+    MAP_OP(238, INSTRUMENTED_END_SEND_A)
+    MAP_OP(239, INSTRUMENTED_RETURN_VALUE_A)
+    MAP_OP(240, INSTRUMENTED_RETURN_CONST_A)
+    MAP_OP(241, INSTRUMENTED_YIELD_VALUE_A)
+    MAP_OP(242, INSTRUMENTED_LOAD_SUPER_ATTR_A)
+    MAP_OP(243, INSTRUMENTED_FOR_ITER_A)
+    MAP_OP(244, INSTRUMENTED_CALL_A)
+    MAP_OP(245, INSTRUMENTED_CALL_KW_A)
+    MAP_OP(246, INSTRUMENTED_CALL_FUNCTION_EX_A)
+    MAP_OP(247, INSTRUMENTED_INSTRUCTION_A)
+    MAP_OP(248, INSTRUMENTED_JUMP_FORWARD_A)
+    MAP_OP(249, INSTRUMENTED_JUMP_BACKWARD_A)
+    MAP_OP(250, INSTRUMENTED_POP_JUMP_IF_TRUE_A)
+    MAP_OP(251, INSTRUMENTED_POP_JUMP_IF_FALSE_A)
+    MAP_OP(252, INSTRUMENTED_POP_JUMP_IF_NONE_A)
+    MAP_OP(253, INSTRUMENTED_POP_JUMP_IF_NOT_NONE_A)
+    MAP_OP(254, INSTRUMENTED_LINE_A)
+END_MAP()

pycdc/bytes/python_3_2.cpp

@@ -0,0 +1,105 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 2)
+    MAP_OP(0, STOP_CODE)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(54, STORE_MAP)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, STORE_LOCALS)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+END_MAP()

pycdc/bytes/python_3_3.cpp

@@ -0,0 +1,105 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 3)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(54, STORE_MAP)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, STORE_LOCALS)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(72, YIELD_FROM)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+END_MAP()

pycdc/bytes/python_3_4.cpp

@@ -0,0 +1,105 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 4)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(54, STORE_MAP)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(72, YIELD_FROM)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(148, LOAD_CLASSDEREF_A)
+END_MAP()

pycdc/bytes/python_3_5.cpp

@@ -0,0 +1,118 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 5)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(16, BINARY_MATRIX_MULTIPLY)
+    MAP_OP(17, INPLACE_MATRIX_MULTIPLY)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(50, GET_AITER)
+    MAP_OP(51, GET_ANEXT)
+    MAP_OP(52, BEFORE_ASYNC_WITH)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, GET_YIELD_FROM_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(72, YIELD_FROM)
+    MAP_OP(73, GET_AWAITABLE)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP_START)
+    MAP_OP(82, WITH_CLEANUP_FINISH)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(134, MAKE_CLOSURE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(140, CALL_FUNCTION_VAR_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_VAR_KW_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(148, LOAD_CLASSDEREF_A)
+    MAP_OP(149, BUILD_LIST_UNPACK_A)
+    MAP_OP(150, BUILD_MAP_UNPACK_A)
+    MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A)
+    MAP_OP(152, BUILD_TUPLE_UNPACK_A)
+    MAP_OP(153, BUILD_SET_UNPACK_A)
+    MAP_OP(154, SETUP_ASYNC_WITH_A)
+END_MAP()

pycdc/bytes/python_3_6.cpp

@@ -0,0 +1,122 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 6)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(16, BINARY_MATRIX_MULTIPLY)
+    MAP_OP(17, INPLACE_MATRIX_MULTIPLY)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(50, GET_AITER)
+    MAP_OP(51, GET_ANEXT)
+    MAP_OP(52, BEFORE_ASYNC_WITH)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, GET_YIELD_FROM_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(72, YIELD_FROM)
+    MAP_OP(73, GET_AWAITABLE)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP_START)
+    MAP_OP(82, WITH_CLEANUP_FINISH)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, SETUP_ANNOTATIONS)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(127, STORE_ANNOTATION_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_EX_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(148, LOAD_CLASSDEREF_A)
+    MAP_OP(149, BUILD_LIST_UNPACK_A)
+    MAP_OP(150, BUILD_MAP_UNPACK_A)
+    MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A)
+    MAP_OP(152, BUILD_TUPLE_UNPACK_A)
+    MAP_OP(153, BUILD_SET_UNPACK_A)
+    MAP_OP(154, SETUP_ASYNC_WITH_A)
+    MAP_OP(155, FORMAT_VALUE_A)
+    MAP_OP(156, BUILD_CONST_KEY_MAP_A)
+    MAP_OP(157, BUILD_STRING_A)
+    MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A)
+END_MAP()

pycdc/bytes/python_3_7.cpp

@@ -0,0 +1,123 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 7)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(16, BINARY_MATRIX_MULTIPLY)
+    MAP_OP(17, INPLACE_MATRIX_MULTIPLY)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(50, GET_AITER)
+    MAP_OP(51, GET_ANEXT)
+    MAP_OP(52, BEFORE_ASYNC_WITH)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, GET_YIELD_FROM_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(72, YIELD_FROM)
+    MAP_OP(73, GET_AWAITABLE)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(80, BREAK_LOOP)
+    MAP_OP(81, WITH_CLEANUP_START)
+    MAP_OP(82, WITH_CLEANUP_FINISH)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, SETUP_ANNOTATIONS)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(119, CONTINUE_LOOP_A)
+    MAP_OP(120, SETUP_LOOP_A)
+    MAP_OP(121, SETUP_EXCEPT_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_EX_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(148, LOAD_CLASSDEREF_A)
+    MAP_OP(149, BUILD_LIST_UNPACK_A)
+    MAP_OP(150, BUILD_MAP_UNPACK_A)
+    MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A)
+    MAP_OP(152, BUILD_TUPLE_UNPACK_A)
+    MAP_OP(153, BUILD_SET_UNPACK_A)
+    MAP_OP(154, SETUP_ASYNC_WITH_A)
+    MAP_OP(155, FORMAT_VALUE_A)
+    MAP_OP(156, BUILD_CONST_KEY_MAP_A)
+    MAP_OP(157, BUILD_STRING_A)
+    MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A)
+    MAP_OP(160, LOAD_METHOD_A)
+    MAP_OP(161, CALL_METHOD_A)
+END_MAP()

pycdc/bytes/python_3_8.cpp

@@ -0,0 +1,124 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 8)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(6, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(16, BINARY_MATRIX_MULTIPLY)
+    MAP_OP(17, INPLACE_MATRIX_MULTIPLY)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(50, GET_AITER)
+    MAP_OP(51, GET_ANEXT)
+    MAP_OP(52, BEFORE_ASYNC_WITH)
+    MAP_OP(53, BEGIN_FINALLY)
+    MAP_OP(54, END_ASYNC_FOR)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, GET_YIELD_FROM_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(72, YIELD_FROM)
+    MAP_OP(73, GET_AWAITABLE)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(81, WITH_CLEANUP_START)
+    MAP_OP(82, WITH_CLEANUP_FINISH)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, SETUP_ANNOTATIONS)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(88, END_FINALLY)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_EX_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(148, LOAD_CLASSDEREF_A)
+    MAP_OP(149, BUILD_LIST_UNPACK_A)
+    MAP_OP(150, BUILD_MAP_UNPACK_A)
+    MAP_OP(151, BUILD_MAP_UNPACK_WITH_CALL_A)
+    MAP_OP(152, BUILD_TUPLE_UNPACK_A)
+    MAP_OP(153, BUILD_SET_UNPACK_A)
+    MAP_OP(154, SETUP_ASYNC_WITH_A)
+    MAP_OP(155, FORMAT_VALUE_A)
+    MAP_OP(156, BUILD_CONST_KEY_MAP_A)
+    MAP_OP(157, BUILD_STRING_A)
+    MAP_OP(158, BUILD_TUPLE_UNPACK_WITH_CALL_A)
+    MAP_OP(160, LOAD_METHOD_A)
+    MAP_OP(161, CALL_METHOD_A)
+    MAP_OP(162, CALL_FINALLY_A)
+    MAP_OP(163, POP_FINALLY_A)
+END_MAP()

pycdc/bytes/python_3_9.cpp

@@ -0,0 +1,123 @@
+#include "bytecode_map.h"
+
+BEGIN_MAP(3, 9)
+    MAP_OP(1, POP_TOP)
+    MAP_OP(2, ROT_TWO)
+    MAP_OP(3, ROT_THREE)
+    MAP_OP(4, DUP_TOP)
+    MAP_OP(5, DUP_TOP_TWO)
+    MAP_OP(6, ROT_FOUR)
+    MAP_OP(9, NOP)
+    MAP_OP(10, UNARY_POSITIVE)
+    MAP_OP(11, UNARY_NEGATIVE)
+    MAP_OP(12, UNARY_NOT)
+    MAP_OP(15, UNARY_INVERT)
+    MAP_OP(16, BINARY_MATRIX_MULTIPLY)
+    MAP_OP(17, INPLACE_MATRIX_MULTIPLY)
+    MAP_OP(19, BINARY_POWER)
+    MAP_OP(20, BINARY_MULTIPLY)
+    MAP_OP(22, BINARY_MODULO)
+    MAP_OP(23, BINARY_ADD)
+    MAP_OP(24, BINARY_SUBTRACT)
+    MAP_OP(25, BINARY_SUBSCR)
+    MAP_OP(26, BINARY_FLOOR_DIVIDE)
+    MAP_OP(27, BINARY_TRUE_DIVIDE)
+    MAP_OP(28, INPLACE_FLOOR_DIVIDE)
+    MAP_OP(29, INPLACE_TRUE_DIVIDE)
+    MAP_OP(48, RERAISE)
+    MAP_OP(49, WITH_EXCEPT_START)
+    MAP_OP(50, GET_AITER)
+    MAP_OP(51, GET_ANEXT)
+    MAP_OP(52, BEFORE_ASYNC_WITH)
+    MAP_OP(54, END_ASYNC_FOR)
+    MAP_OP(55, INPLACE_ADD)
+    MAP_OP(56, INPLACE_SUBTRACT)
+    MAP_OP(57, INPLACE_MULTIPLY)
+    MAP_OP(59, INPLACE_MODULO)
+    MAP_OP(60, STORE_SUBSCR)
+    MAP_OP(61, DELETE_SUBSCR)
+    MAP_OP(62, BINARY_LSHIFT)
+    MAP_OP(63, BINARY_RSHIFT)
+    MAP_OP(64, BINARY_AND)
+    MAP_OP(65, BINARY_XOR)
+    MAP_OP(66, BINARY_OR)
+    MAP_OP(67, INPLACE_POWER)
+    MAP_OP(68, GET_ITER)
+    MAP_OP(69, GET_YIELD_FROM_ITER)
+    MAP_OP(70, PRINT_EXPR)
+    MAP_OP(71, LOAD_BUILD_CLASS)
+    MAP_OP(72, YIELD_FROM)
+    MAP_OP(73, GET_AWAITABLE)
+    MAP_OP(74, LOAD_ASSERTION_ERROR)
+    MAP_OP(75, INPLACE_LSHIFT)
+    MAP_OP(76, INPLACE_RSHIFT)
+    MAP_OP(77, INPLACE_AND)
+    MAP_OP(78, INPLACE_XOR)
+    MAP_OP(79, INPLACE_OR)
+    MAP_OP(82, LIST_TO_TUPLE)
+    MAP_OP(83, RETURN_VALUE)
+    MAP_OP(84, IMPORT_STAR)
+    MAP_OP(85, SETUP_ANNOTATIONS)
+    MAP_OP(86, YIELD_VALUE)
+    MAP_OP(87, POP_BLOCK)
+    MAP_OP(89, POP_EXCEPT)
+    MAP_OP(90, STORE_NAME_A)
+    MAP_OP(91, DELETE_NAME_A)
+    MAP_OP(92, UNPACK_SEQUENCE_A)
+    MAP_OP(93, FOR_ITER_A)
+    MAP_OP(94, UNPACK_EX_A)
+    MAP_OP(95, STORE_ATTR_A)
+    MAP_OP(96, DELETE_ATTR_A)
+    MAP_OP(97, STORE_GLOBAL_A)
+    MAP_OP(98, DELETE_GLOBAL_A)
+    MAP_OP(100, LOAD_CONST_A)
+    MAP_OP(101, LOAD_NAME_A)
+    MAP_OP(102, BUILD_TUPLE_A)
+    MAP_OP(103, BUILD_LIST_A)
+    MAP_OP(104, BUILD_SET_A)
+    MAP_OP(105, BUILD_MAP_A)
+    MAP_OP(106, LOAD_ATTR_A)
+    MAP_OP(107, COMPARE_OP_A)
+    MAP_OP(108, IMPORT_NAME_A)
+    MAP_OP(109, IMPORT_FROM_A)
+    MAP_OP(110, JUMP_FORWARD_A)
+    MAP_OP(111, JUMP_IF_FALSE_OR_POP_A)
+    MAP_OP(112, JUMP_IF_TRUE_OR_POP_A)
+    MAP_OP(113, JUMP_ABSOLUTE_A)
+    MAP_OP(114, POP_JUMP_IF_FALSE_A)
+    MAP_OP(115, POP_JUMP_IF_TRUE_A)
+    MAP_OP(116, LOAD_GLOBAL_A)
+    MAP_OP(117, IS_OP_A)
+    MAP_OP(118, CONTAINS_OP_A)
+    MAP_OP(121, JUMP_IF_NOT_EXC_MATCH_A)
+    MAP_OP(122, SETUP_FINALLY_A)
+    MAP_OP(124, LOAD_FAST_A)
+    MAP_OP(125, STORE_FAST_A)
+    MAP_OP(126, DELETE_FAST_A)
+    MAP_OP(130, RAISE_VARARGS_A)
+    MAP_OP(131, CALL_FUNCTION_A)
+    MAP_OP(132, MAKE_FUNCTION_A)
+    MAP_OP(133, BUILD_SLICE_A)
+    MAP_OP(135, LOAD_CLOSURE_A)
+    MAP_OP(136, LOAD_DEREF_A)
+    MAP_OP(137, STORE_DEREF_A)
+    MAP_OP(138, DELETE_DEREF_A)
+    MAP_OP(141, CALL_FUNCTION_KW_A)
+    MAP_OP(142, CALL_FUNCTION_EX_A)
+    MAP_OP(143, SETUP_WITH_A)
+    MAP_OP(144, EXTENDED_ARG_A)
+    MAP_OP(145, LIST_APPEND_A)
+    MAP_OP(146, SET_ADD_A)
+    MAP_OP(147, MAP_ADD_A)
+    MAP_OP(148, LOAD_CLASSDEREF_A)
+    MAP_OP(154, SETUP_ASYNC_WITH_A)
+    MAP_OP(155, FORMAT_VALUE_A)
+    MAP_OP(156, BUILD_CONST_KEY_MAP_A)
+    MAP_OP(157, BUILD_STRING_A)
+    MAP_OP(160, LOAD_METHOD_A)
+    MAP_OP(161, CALL_METHOD_A)
+    MAP_OP(162, LIST_EXTEND_A)
+    MAP_OP(163, SET_UPDATE_A)
+    MAP_OP(164, DICT_MERGE_A)
+    MAP_OP(165, DICT_UPDATE_A)
+END_MAP()