tutorials/GitHub_MD_rendering/Disassembling python bytecode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**What?** Disassembling python bytecode\n",
    "\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `dis` module in python\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "- In Python, the dis module allows disassembly of Python code into the individual instructions executed by the Python interpreter (usually cPython as this is the most popular implementation) for each line. \n",
    "\n",
    "- This is useful for analysing and fine-tuning your code.\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-28T13:06:13.321280Z",
     "start_time": "2023-01-28T13:06:13.310419Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bytecode',\n",
       " 'COMPILER_FLAG_NAMES',\n",
       " 'EXTENDED_ARG',\n",
       " 'FORMAT_VALUE',\n",
       " 'FORMAT_VALUE_CONVERTERS',\n",
       " 'HAVE_ARGUMENT',\n",
       " 'Instruction',\n",
       " 'MAKE_FUNCTION',\n",
       " 'MAKE_FUNCTION_FLAGS',\n",
       " '_Instruction',\n",
       " '_OPARG_WIDTH',\n",
       " '_OPNAME_WIDTH',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_disassemble_bytes',\n",
       " '_disassemble_recursive',\n",
       " '_disassemble_str',\n",
       " '_format_code_info',\n",
       " '_get_code_object',\n",
       " '_get_const_info',\n",
       " '_get_instructions_bytes',\n",
       " '_get_name_info',\n",
       " '_have_code',\n",
       " '_test',\n",
       " '_try_compile',\n",
       " '_unpack_opargs',\n",
       " 'cmp_op',\n",
       " 'code_info',\n",
       " 'collections',\n",
       " 'dis',\n",
       " 'disassemble',\n",
       " 'disco',\n",
       " 'distb',\n",
       " 'findlabels',\n",
       " 'findlinestarts',\n",
       " 'get_instructions',\n",
       " 'hascompare',\n",
       " 'hasconst',\n",
       " 'hasfree',\n",
       " 'hasjabs',\n",
       " 'hasjrel',\n",
       " 'haslocal',\n",
       " 'hasname',\n",
       " 'hasnargs',\n",
       " 'io',\n",
       " 'opmap',\n",
       " 'opname',\n",
       " 'pretty_flags',\n",
       " 'show_code',\n",
       " 'stack_effect',\n",
       " 'sys',\n",
       " 'types']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(dis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basics\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "- The main method will use is `dis.dis`. \n",
    "- It takes either a function, method, class, module, code string, generator or byte sequence of raw bytecode and prints the disassembly of that code object to stdout.\n",
    "- In the case of a class, it will disassemble each method (also static and class methods).\n",
    "- For a module, it disassembles all functions in that module.\n",
    "- The columns returned are the following:\n",
    "    - The original line of code the disassembly is referencing.\n",
    "    - The address of the bytecode instruction.\n",
    "    - The name of the instruction.\n",
    "    - The index of the argument in the code block’s name and constant table.\n",
    "    - The human-friendly mapping from the argument index (4) to the actual value or name being referenced    \n",
    "\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feeding a module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-28T13:01:51.569193Z",
     "start_time": "2023-01-28T13:01:51.337347Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Disassembly of Bytecode:\n",
      "Disassembly of __init__:\n",
      "488           0 LOAD_GLOBAL              0 (_get_code_object)\n",
      "              2 LOAD_FAST                1 (x)\n",
      "              4 CALL_FUNCTION            1\n",
      "              6 DUP_TOP\n",
      "              8 LOAD_FAST                0 (self)\n",
      "             10 STORE_ATTR               1 (codeobj)\n",
      "             12 STORE_FAST               4 (co)\n",
      "\n",
      "489          14 LOAD_FAST                2 (first_line)\n",
      "             16 LOAD_CONST               0 (None)\n",
      "             18 IS_OP                    0\n",
      "             20 POP_JUMP_IF_FALSE       38\n",
      "\n",
      "490          22 LOAD_FAST                4 (co)\n",
      "             24 LOAD_ATTR                2 (co_firstlineno)\n",
      "             26 LOAD_FAST                0 (self)\n",
      "             28 STORE_ATTR               3 (first_line)\n",
      "\n",
      "491          30 LOAD_CONST               1 (0)\n",
      "             32 LOAD_FAST                0 (self)\n",
      "             34 STORE_ATTR               4 (_line_offset)\n",
      "             36 JUMP_FORWARD            18 (to 56)\n",
      "\n",
      "493     >>   38 LOAD_FAST                2 (first_line)\n",
      "             40 LOAD_FAST                0 (self)\n",
      "             42 STORE_ATTR               3 (first_line)\n",
      "\n",
      "494          44 LOAD_FAST                2 (first_line)\n",
      "             46 LOAD_FAST                4 (co)\n",
      "             48 LOAD_ATTR                2 (co_firstlineno)\n",
      "             50 BINARY_SUBTRACT\n",
      "             52 LOAD_FAST                0 (self)\n",
      "             54 STORE_ATTR               4 (_line_offset)\n",
      "\n",
      "495     >>   56 LOAD_FAST                4 (co)\n",
      "             58 LOAD_ATTR                5 (co_cellvars)\n",
      "             60 LOAD_FAST                4 (co)\n",
      "             62 LOAD_ATTR                6 (co_freevars)\n",
      "             64 BINARY_ADD\n",
      "             66 LOAD_FAST                0 (self)\n",
      "             68 STORE_ATTR               7 (_cell_names)\n",
      "\n",
      "496          70 LOAD_GLOBAL              8 (dict)\n",
      "             72 LOAD_GLOBAL              9 (findlinestarts)\n",
      "             74 LOAD_FAST                4 (co)\n",
      "             76 CALL_FUNCTION            1\n",
      "             78 CALL_FUNCTION            1\n",
      "             80 LOAD_FAST                0 (self)\n",
      "             82 STORE_ATTR              10 (_linestarts)\n",
      "\n",
      "497          84 LOAD_FAST                1 (x)\n",
      "             86 LOAD_FAST                0 (self)\n",
      "             88 STORE_ATTR              11 (_original_object)\n",
      "\n",
      "498          90 LOAD_FAST                3 (current_offset)\n",
      "             92 LOAD_FAST                0 (self)\n",
      "             94 STORE_ATTR              12 (current_offset)\n",
      "             96 LOAD_CONST               0 (None)\n",
      "             98 RETURN_VALUE\n",
      "\n",
      "Disassembly of __iter__:\n",
      "501           0 LOAD_FAST                0 (self)\n",
      "              2 LOAD_ATTR                0 (codeobj)\n",
      "              4 STORE_FAST               1 (co)\n",
      "\n",
      "502           6 LOAD_GLOBAL              1 (_get_instructions_bytes)\n",
      "              8 LOAD_FAST                1 (co)\n",
      "             10 LOAD_ATTR                2 (co_code)\n",
      "             12 LOAD_FAST                1 (co)\n",
      "             14 LOAD_ATTR                3 (co_varnames)\n",
      "             16 LOAD_FAST                1 (co)\n",
      "             18 LOAD_ATTR                4 (co_names)\n",
      "\n",
      "503          20 LOAD_FAST                1 (co)\n",
      "             22 LOAD_ATTR                5 (co_consts)\n",
      "             24 LOAD_FAST                0 (self)\n",
      "             26 LOAD_ATTR                6 (_cell_names)\n",
      "\n",
      "504          28 LOAD_FAST                0 (self)\n",
      "             30 LOAD_ATTR                7 (_linestarts)\n",
      "\n",
      "505          32 LOAD_FAST                0 (self)\n",
      "             34 LOAD_ATTR                8 (_line_offset)\n",
      "\n",
      "502          36 LOAD_CONST               1 (('line_offset',))\n",
      "             38 CALL_FUNCTION_KW         7\n",
      "             40 RETURN_VALUE\n",
      "\n",
      "Disassembly of __repr__:\n",
      "508           0 LOAD_CONST               1 ('{}({!r})')\n",
      "              2 LOAD_METHOD              0 (format)\n",
      "              4 LOAD_FAST                0 (self)\n",
      "              6 LOAD_ATTR                1 (__class__)\n",
      "              8 LOAD_ATTR                2 (__name__)\n",
      "\n",
      "509          10 LOAD_FAST                0 (self)\n",
      "             12 LOAD_ATTR                3 (_original_object)\n",
      "\n",
      "508          14 CALL_METHOD              2\n",
      "             16 RETURN_VALUE\n",
      "\n",
      "Disassembly of dis:\n",
      "524           0 LOAD_FAST                0 (self)\n",
      "              2 LOAD_ATTR                0 (codeobj)\n",
      "              4 STORE_FAST               1 (co)\n",
      "\n",
      "525           6 LOAD_FAST                0 (self)\n",
      "              8 LOAD_ATTR                1 (current_offset)\n",
      "             10 LOAD_CONST               1 (None)\n",
      "             12 IS_OP                    1\n",
      "             14 POP_JUMP_IF_FALSE       24\n",
      "\n",
      "526          16 LOAD_FAST                0 (self)\n",
      "             18 LOAD_ATTR                1 (current_offset)\n",
      "             20 STORE_FAST               2 (offset)\n",
      "             22 JUMP_FORWARD             4 (to 28)\n",
      "\n",
      "528     >>   24 LOAD_CONST               2 (-1)\n",
      "             26 STORE_FAST               2 (offset)\n",
      "\n",
      "529     >>   28 LOAD_GLOBAL              2 (io)\n",
      "             30 LOAD_METHOD              3 (StringIO)\n",
      "             32 CALL_METHOD              0\n",
      "             34 SETUP_WITH              64 (to 100)\n",
      "             36 STORE_FAST               3 (output)\n",
      "\n",
      "530          38 LOAD_GLOBAL              4 (_disassemble_bytes)\n",
      "             40 LOAD_FAST                1 (co)\n",
      "             42 LOAD_ATTR                5 (co_code)\n",
      "             44 LOAD_FAST                1 (co)\n",
      "             46 LOAD_ATTR                6 (co_varnames)\n",
      "\n",
      "531          48 LOAD_FAST                1 (co)\n",
      "             50 LOAD_ATTR                7 (co_names)\n",
      "             52 LOAD_FAST                1 (co)\n",
      "             54 LOAD_ATTR                8 (co_consts)\n",
      "\n",
      "532          56 LOAD_FAST                0 (self)\n",
      "             58 LOAD_ATTR                9 (_cell_names)\n",
      "\n",
      "533          60 LOAD_FAST                0 (self)\n",
      "             62 LOAD_ATTR               10 (_linestarts)\n",
      "\n",
      "534          64 LOAD_FAST                0 (self)\n",
      "             66 LOAD_ATTR               11 (_line_offset)\n",
      "\n",
      "535          68 LOAD_FAST                3 (output)\n",
      "\n",
      "536          70 LOAD_FAST                2 (offset)\n",
      "\n",
      "530          72 LOAD_CONST               3 (('varnames', 'names', 'constants', 'cells', 'linestarts', 'line_offset', 'file', 'lasti'))\n",
      "             74 CALL_FUNCTION_KW         9\n",
      "             76 POP_TOP\n",
      "\n",
      "537          78 LOAD_FAST                3 (output)\n",
      "             80 LOAD_METHOD             12 (getvalue)\n",
      "             82 CALL_METHOD              0\n",
      "             84 POP_BLOCK\n",
      "             86 ROT_TWO\n",
      "             88 LOAD_CONST               1 (None)\n",
      "             90 DUP_TOP\n",
      "             92 DUP_TOP\n",
      "             94 CALL_FUNCTION            3\n",
      "             96 POP_TOP\n",
      "             98 RETURN_VALUE\n",
      "        >>  100 WITH_EXCEPT_START\n",
      "            102 POP_JUMP_IF_TRUE       106\n",
      "            104 RERAISE\n",
      "        >>  106 POP_TOP\n",
      "            108 POP_TOP\n",
      "            110 POP_TOP\n",
      "            112 POP_EXCEPT\n",
      "            114 POP_TOP\n",
      "            116 LOAD_CONST               1 (None)\n",
      "            118 RETURN_VALUE\n",
      "\n",
      "Disassembly of from_traceback:\n",
      "514     >>    0 LOAD_FAST                1 (tb)\n",
      "              2 LOAD_ATTR                0 (tb_next)\n",
      "              4 POP_JUMP_IF_FALSE       14\n",
      "\n",
      "515           6 LOAD_FAST                1 (tb)\n",
      "              8 LOAD_ATTR                0 (tb_next)\n",
      "             10 STORE_FAST               1 (tb)\n",
      "             12 JUMP_ABSOLUTE            0\n",
      "\n",
      "516     >>   14 LOAD_FAST                0 (cls)\n",
      "             16 LOAD_FAST                1 (tb)\n",
      "             18 LOAD_ATTR                1 (tb_frame)\n",
      "             20 LOAD_ATTR                2 (f_code)\n",
      "             22 LOAD_FAST                1 (tb)\n",
      "             24 LOAD_ATTR                3 (tb_lasti)\n",
      "             26 LOAD_CONST               1 (('current_offset',))\n",
      "             28 CALL_FUNCTION_KW         2\n",
      "             30 RETURN_VALUE\n",
      "\n",
      "Disassembly of info:\n",
      "520           0 LOAD_GLOBAL              0 (_format_code_info)\n",
      "              2 LOAD_FAST                0 (self)\n",
      "              4 LOAD_ATTR                1 (codeobj)\n",
      "              6 CALL_FUNCTION            1\n",
      "              8 RETURN_VALUE\n",
      "\n",
      "\n",
      "Disassembly of Instruction:\n",
      "Disassembly of _disassemble:\n",
      "230           0 BUILD_LIST               0\n",
      "              2 STORE_FAST               4 (fields)\n",
      "\n",
      "232           4 LOAD_FAST                1 (lineno_width)\n",
      "              6 POP_JUMP_IF_FALSE       58\n",
      "\n",
      "233           8 LOAD_FAST                0 (self)\n",
      "             10 LOAD_ATTR                0 (starts_line)\n",
      "             12 LOAD_CONST               1 (None)\n",
      "             14 IS_OP                    1\n",
      "             16 POP_JUMP_IF_FALSE       44\n",
      "\n",
      "234          18 LOAD_CONST               2 ('%%%dd')\n",
      "             20 LOAD_FAST                1 (lineno_width)\n",
      "             22 BINARY_MODULO\n",
      "             24 STORE_FAST               5 (lineno_fmt)\n",
      "\n",
      "235          26 LOAD_FAST                4 (fields)\n",
      "             28 LOAD_METHOD              1 (append)\n",
      "             30 LOAD_FAST                5 (lineno_fmt)\n",
      "             32 LOAD_FAST                0 (self)\n",
      "             34 LOAD_ATTR                0 (starts_line)\n",
      "             36 BINARY_MODULO\n",
      "             38 CALL_METHOD              1\n",
      "             40 POP_TOP\n",
      "             42 JUMP_FORWARD            14 (to 58)\n",
      "\n",
      "237     >>   44 LOAD_FAST                4 (fields)\n",
      "             46 LOAD_METHOD              1 (append)\n",
      "             48 LOAD_CONST               3 (' ')\n",
      "             50 LOAD_FAST                1 (lineno_width)\n",
      "             52 BINARY_MULTIPLY\n",
      "             54 CALL_METHOD              1\n",
      "             56 POP_TOP\n",
      "\n",
      "239     >>   58 LOAD_FAST                2 (mark_as_current)\n",
      "             60 POP_JUMP_IF_FALSE       74\n",
      "\n",
      "240          62 LOAD_FAST                4 (fields)\n",
      "             64 LOAD_METHOD              1 (append)\n",
      "             66 LOAD_CONST               4 ('-->')\n",
      "             68 CALL_METHOD              1\n",
      "             70 POP_TOP\n",
      "             72 JUMP_FORWARD            10 (to 84)\n",
      "\n",
      "242     >>   74 LOAD_FAST                4 (fields)\n",
      "             76 LOAD_METHOD              1 (append)\n",
      "             78 LOAD_CONST               5 ('   ')\n",
      "             80 CALL_METHOD              1\n",
      "             82 POP_TOP\n",
      "\n",
      "244     >>   84 LOAD_FAST                0 (self)\n",
      "             86 LOAD_ATTR                2 (is_jump_target)\n",
      "             88 POP_JUMP_IF_FALSE      102\n",
      "\n",
      "245          90 LOAD_FAST                4 (fields)\n",
      "             92 LOAD_METHOD              1 (append)\n",
      "             94 LOAD_CONST               6 ('>>')\n",
      "             96 CALL_METHOD              1\n",
      "             98 POP_TOP\n",
      "            100 JUMP_FORWARD            10 (to 112)\n",
      "\n",
      "247     >>  102 LOAD_FAST                4 (fields)\n",
      "            104 LOAD_METHOD              1 (append)\n",
      "            106 LOAD_CONST               7 ('  ')\n",
      "            108 CALL_METHOD              1\n",
      "            110 POP_TOP\n",
      "\n",
      "249     >>  112 LOAD_FAST                4 (fields)\n",
      "            114 LOAD_METHOD              1 (append)\n",
      "            116 LOAD_GLOBAL              3 (repr)\n",
      "            118 LOAD_FAST                0 (self)\n",
      "            120 LOAD_ATTR                4 (offset)\n",
      "            122 CALL_FUNCTION            1\n",
      "            124 LOAD_METHOD              5 (rjust)\n",
      "            126 LOAD_FAST                3 (offset_width)\n",
      "            128 CALL_METHOD              1\n",
      "            130 CALL_METHOD              1\n",
      "            132 POP_TOP\n",
      "\n",
      "251         134 LOAD_FAST                4 (fields)\n",
      "            136 LOAD_METHOD              1 (append)\n",
      "            138 LOAD_FAST                0 (self)\n",
      "            140 LOAD_ATTR                6 (opname)\n",
      "            142 LOAD_METHOD              7 (ljust)\n",
      "            144 LOAD_GLOBAL              8 (_OPNAME_WIDTH)\n",
      "            146 CALL_METHOD              1\n",
      "            148 CALL_METHOD              1\n",
      "            150 POP_TOP\n",
      "\n",
      "253         152 LOAD_FAST                0 (self)\n",
      "            154 LOAD_ATTR                9 (arg)\n",
      "            156 LOAD_CONST               1 (None)\n",
      "            158 IS_OP                    1\n",
      "            160 POP_JUMP_IF_FALSE      210\n",
      "\n",
      "254         162 LOAD_FAST                4 (fields)\n",
      "            164 LOAD_METHOD              1 (append)\n",
      "            166 LOAD_GLOBAL              3 (repr)\n",
      "            168 LOAD_FAST                0 (self)\n",
      "            170 LOAD_ATTR                9 (arg)\n",
      "            172 CALL_FUNCTION            1\n",
      "            174 LOAD_METHOD              5 (rjust)\n",
      "            176 LOAD_GLOBAL             10 (_OPARG_WIDTH)\n",
      "            178 CALL_METHOD              1\n",
      "            180 CALL_METHOD              1\n",
      "            182 POP_TOP\n",
      "\n",
      "256         184 LOAD_FAST                0 (self)\n",
      "            186 LOAD_ATTR               11 (argrepr)\n",
      "            188 POP_JUMP_IF_FALSE      210\n",
      "\n",
      "257         190 LOAD_FAST                4 (fields)\n",
      "            192 LOAD_METHOD              1 (append)\n",
      "            194 LOAD_CONST               8 ('(')\n",
      "            196 LOAD_FAST                0 (self)\n",
      "            198 LOAD_ATTR               11 (argrepr)\n",
      "            200 BINARY_ADD\n",
      "            202 LOAD_CONST               9 (')')\n",
      "            204 BINARY_ADD\n",
      "            206 CALL_METHOD              1\n",
      "            208 POP_TOP\n",
      "\n",
      "258     >>  210 LOAD_CONST               3 (' ')\n",
      "            212 LOAD_METHOD             12 (join)\n",
      "            214 LOAD_FAST                4 (fields)\n",
      "            216 CALL_METHOD              1\n",
      "            218 LOAD_METHOD             13 (rstrip)\n",
      "            220 CALL_METHOD              0\n",
      "            222 RETURN_VALUE\n",
      "\n",
      "\n",
      "Disassembly of _Instruction:\n",
      "Disassembly of __getnewargs__:\n",
      "466           0 LOAD_DEREF               0 (_tuple)\n",
      "              2 LOAD_FAST                0 (self)\n",
      "              4 CALL_FUNCTION            1\n",
      "              6 RETURN_VALUE\n",
      "\n",
      "Disassembly of __new__:\n",
      "  1           0 LOAD_GLOBAL              0 (_tuple_new)\n",
      "              2 LOAD_FAST                0 (_cls)\n",
      "              4 LOAD_FAST                1 (opname)\n",
      "              6 LOAD_FAST                2 (opcode)\n",
      "              8 LOAD_FAST                3 (arg)\n",
      "             10 LOAD_FAST                4 (argval)\n",
      "             12 LOAD_FAST                5 (argrepr)\n",
      "             14 LOAD_FAST                6 (offset)\n",
      "             16 LOAD_FAST                7 (starts_line)\n",
      "             18 LOAD_FAST                8 (is_jump_target)\n",
      "             20 BUILD_TUPLE              8\n",
      "             22 CALL_FUNCTION            2\n",
      "             24 RETURN_VALUE\n",
      "\n",
      "Disassembly of __repr__:\n",
      "458           0 LOAD_FAST                0 (self)\n",
      "              2 LOAD_ATTR                0 (__class__)\n",
      "              4 LOAD_ATTR                1 (__name__)\n",
      "              6 LOAD_DEREF               0 (repr_fmt)\n",
      "              8 LOAD_FAST                0 (self)\n",
      "             10 BINARY_MODULO\n",
      "             12 BINARY_ADD\n",
      "             14 RETURN_VALUE\n",
      "\n",
      "Disassembly of _asdict:\n",
      "462           0 LOAD_DEREF               0 (_dict)\n",
      "              2 LOAD_DEREF               1 (_zip)\n",
      "              4 LOAD_FAST                0 (self)\n",
      "              6 LOAD_ATTR                0 (_fields)\n",
      "              8 LOAD_FAST                0 (self)\n",
      "             10 CALL_FUNCTION            2\n",
      "             12 CALL_FUNCTION            1\n",
      "             14 RETURN_VALUE\n",
      "\n",
      "Disassembly of _make:\n",
      "439           0 LOAD_DEREF               2 (tuple_new)\n",
      "              2 LOAD_FAST                0 (cls)\n",
      "              4 LOAD_FAST                1 (iterable)\n",
      "              6 CALL_FUNCTION            2\n",
      "              8 STORE_FAST               2 (result)\n",
      "\n",
      "440          10 LOAD_DEREF               0 (_len)\n",
      "             12 LOAD_FAST                2 (result)\n",
      "             14 CALL_FUNCTION            1\n",
      "             16 LOAD_DEREF               1 (num_fields)\n",
      "             18 COMPARE_OP               3 (!=)\n",
      "             20 POP_JUMP_IF_FALSE       46\n",
      "\n",
      "441          22 LOAD_GLOBAL              0 (TypeError)\n",
      "             24 LOAD_CONST               1 ('Expected ')\n",
      "             26 LOAD_DEREF               1 (num_fields)\n",
      "             28 FORMAT_VALUE             0\n",
      "             30 LOAD_CONST               2 (' arguments, got ')\n",
      "             32 LOAD_GLOBAL              1 (len)\n",
      "             34 LOAD_FAST                2 (result)\n",
      "             36 CALL_FUNCTION            1\n",
      "             38 FORMAT_VALUE             0\n",
      "             40 BUILD_STRING             4\n",
      "             42 CALL_FUNCTION            1\n",
      "             44 RAISE_VARARGS            1\n",
      "\n",
      "442     >>   46 LOAD_FAST                2 (result)\n",
      "             48 RETURN_VALUE\n",
      "\n",
      "Disassembly of _replace:\n",
      "448           0 LOAD_FAST                0 (self)\n",
      "              2 LOAD_METHOD              0 (_make)\n",
      "              4 LOAD_DEREF               0 (_map)\n",
      "              6 LOAD_FAST                1 (kwds)\n",
      "              8 LOAD_ATTR                1 (pop)\n",
      "             10 LOAD_DEREF               1 (field_names)\n",
      "             12 LOAD_FAST                0 (self)\n",
      "             14 CALL_FUNCTION            3\n",
      "             16 CALL_METHOD              1\n",
      "             18 STORE_FAST               2 (result)\n",
      "\n",
      "449          20 LOAD_FAST                1 (kwds)\n",
      "             22 POP_JUMP_IF_FALSE       42\n",
      "\n",
      "450          24 LOAD_GLOBAL              2 (ValueError)\n",
      "             26 LOAD_CONST               1 ('Got unexpected field names: ')\n",
      "             28 LOAD_GLOBAL              3 (list)\n",
      "             30 LOAD_FAST                1 (kwds)\n",
      "             32 CALL_FUNCTION            1\n",
      "             34 FORMAT_VALUE             2 (repr)\n",
      "             36 BUILD_STRING             2\n",
      "             38 CALL_FUNCTION            1\n",
      "             40 RAISE_VARARGS            1\n",
      "\n",
      "451     >>   42 LOAD_FAST                2 (result)\n",
      "             44 RETURN_VALUE\n",
      "\n",
      "\n",
      "Disassembly of _disassemble_bytes:\n",
      "387           0 LOAD_FAST                6 (linestarts)\n",
      "              2 LOAD_CONST               0 (None)\n",
      "              4 IS_OP                    1\n",
      "              6 STORE_FAST               9 (show_lineno)\n",
      "\n",
      "388           8 LOAD_FAST                9 (show_lineno)\n",
      "             10 POP_JUMP_IF_FALSE       56\n",
      "\n",
      "389          12 LOAD_GLOBAL              0 (max)\n",
      "             14 LOAD_FAST                6 (linestarts)\n",
      "             16 LOAD_METHOD              1 (values)\n",
      "             18 CALL_METHOD              0\n",
      "             20 CALL_FUNCTION            1\n",
      "             22 LOAD_FAST                8 (line_offset)\n",
      "             24 BINARY_ADD\n",
      "             26 STORE_FAST              10 (maxlineno)\n",
      "\n",
      "390          28 LOAD_FAST               10 (maxlineno)\n",
      "             30 LOAD_CONST               1 (1000)\n",
      "             32 COMPARE_OP               5 (>=)\n",
      "             34 POP_JUMP_IF_FALSE       50\n",
      "\n",
      "391          36 LOAD_GLOBAL              2 (len)\n",
      "             38 LOAD_GLOBAL              3 (str)\n",
      "             40 LOAD_FAST               10 (maxlineno)\n",
      "             42 CALL_FUNCTION            1\n",
      "             44 CALL_FUNCTION            1\n",
      "             46 STORE_FAST              11 (lineno_width)\n",
      "             48 JUMP_ABSOLUTE           60\n",
      "\n",
      "393     >>   50 LOAD_CONST               2 (3)\n",
      "             52 STORE_FAST              11 (lineno_width)\n",
      "             54 JUMP_FORWARD             4 (to 60)\n",
      "\n",
      "395     >>   56 LOAD_CONST               3 (0)\n",
      "             58 STORE_FAST              11 (lineno_width)\n",
      "\n",
      "396     >>   60 LOAD_GLOBAL              2 (len)\n",
      "             62 LOAD_FAST                0 (code)\n",
      "             64 CALL_FUNCTION            1\n",
      "             66 LOAD_CONST               4 (2)\n",
      "             68 BINARY_SUBTRACT\n",
      "             70 STORE_FAST              12 (maxoffset)\n",
      "\n",
      "397          72 LOAD_FAST               12 (maxoffset)\n",
      "             74 LOAD_CONST               5 (10000)\n",
      "             76 COMPARE_OP               5 (>=)\n",
      "             78 POP_JUMP_IF_FALSE       94\n",
      "\n",
      "398          80 LOAD_GLOBAL              2 (len)\n",
      "             82 LOAD_GLOBAL              3 (str)\n",
      "             84 LOAD_FAST               12 (maxoffset)\n",
      "             86 CALL_FUNCTION            1\n",
      "             88 CALL_FUNCTION            1\n",
      "             90 STORE_FAST              13 (offset_width)\n",
      "             92 JUMP_FORWARD             4 (to 98)\n",
      "\n",
      "400     >>   94 LOAD_CONST               6 (4)\n",
      "             96 STORE_FAST              13 (offset_width)\n",
      "\n",
      "401     >>   98 LOAD_GLOBAL              4 (_get_instructions_bytes)\n",
      "            100 LOAD_FAST                0 (code)\n",
      "            102 LOAD_FAST                2 (varnames)\n",
      "            104 LOAD_FAST                3 (names)\n",
      "\n",
      "402         106 LOAD_FAST                4 (constants)\n",
      "            108 LOAD_FAST                5 (cells)\n",
      "            110 LOAD_FAST                6 (linestarts)\n",
      "\n",
      "403         112 LOAD_FAST                8 (line_offset)\n",
      "\n",
      "401         114 LOAD_CONST               7 (('line_offset',))\n",
      "            116 CALL_FUNCTION_KW         7\n",
      "            118 GET_ITER\n",
      "        >>  120 FOR_ITER                74 (to 196)\n",
      "            122 STORE_FAST              14 (instr)\n",
      "\n",
      "404         124 LOAD_FAST                9 (show_lineno)\n",
      "            126 JUMP_IF_FALSE_OR_POP   146\n",
      "\n",
      "405         128 LOAD_FAST               14 (instr)\n",
      "            130 LOAD_ATTR                5 (starts_line)\n",
      "            132 LOAD_CONST               0 (None)\n",
      "            134 IS_OP                    1\n",
      "\n",
      "404         136 JUMP_IF_FALSE_OR_POP   146\n",
      "\n",
      "406         138 LOAD_FAST               14 (instr)\n",
      "            140 LOAD_ATTR                6 (offset)\n",
      "            142 LOAD_CONST               3 (0)\n",
      "            144 COMPARE_OP               4 (>)\n",
      "\n",
      "404     >>  146 STORE_FAST              15 (new_source_line)\n",
      "\n",
      "407         148 LOAD_FAST               15 (new_source_line)\n",
      "            150 POP_JUMP_IF_FALSE      162\n",
      "\n",
      "408         152 LOAD_GLOBAL              7 (print)\n",
      "            154 LOAD_FAST                7 (file)\n",
      "            156 LOAD_CONST               8 (('file',))\n",
      "            158 CALL_FUNCTION_KW         1\n",
      "            160 POP_TOP\n",
      "\n",
      "409     >>  162 LOAD_FAST               14 (instr)\n",
      "            164 LOAD_ATTR                6 (offset)\n",
      "            166 LOAD_FAST                1 (lasti)\n",
      "            168 COMPARE_OP               2 (==)\n",
      "            170 STORE_FAST              16 (is_current_instr)\n",
      "\n",
      "410         172 LOAD_GLOBAL              7 (print)\n",
      "            174 LOAD_FAST               14 (instr)\n",
      "            176 LOAD_METHOD              8 (_disassemble)\n",
      "            178 LOAD_FAST               11 (lineno_width)\n",
      "            180 LOAD_FAST               16 (is_current_instr)\n",
      "            182 LOAD_FAST               13 (offset_width)\n",
      "            184 CALL_METHOD              3\n",
      "\n",
      "411         186 LOAD_FAST                7 (file)\n",
      "\n",
      "410         188 LOAD_CONST               8 (('file',))\n",
      "            190 CALL_FUNCTION_KW         2\n",
      "            192 POP_TOP\n",
      "            194 JUMP_ABSOLUTE          120\n",
      "        >>  196 LOAD_CONST               0 (None)\n",
      "            198 RETURN_VALUE\n",
      "\n",
      "Disassembly of _disassemble_recursive:\n",
      "373           0 LOAD_GLOBAL              0 (disassemble)\n",
      "              2 LOAD_FAST                0 (co)\n",
      "              4 LOAD_FAST                1 (file)\n",
      "              6 LOAD_CONST               1 (('file',))\n",
      "              8 CALL_FUNCTION_KW         2\n",
      "             10 POP_TOP\n",
      "\n",
      "374          12 LOAD_FAST                2 (depth)\n",
      "             14 LOAD_CONST               0 (None)\n",
      "             16 IS_OP                    0\n",
      "             18 POP_JUMP_IF_TRUE        28\n",
      "             20 LOAD_FAST                2 (depth)\n",
      "             22 LOAD_CONST               2 (0)\n",
      "             24 COMPARE_OP               4 (>)\n",
      "             26 POP_JUMP_IF_FALSE      108\n",
      "\n",
      "375     >>   28 LOAD_FAST                2 (depth)\n",
      "             30 LOAD_CONST               0 (None)\n",
      "             32 IS_OP                    1\n",
      "             34 POP_JUMP_IF_FALSE       44\n",
      "\n",
      "376          36 LOAD_FAST                2 (depth)\n",
      "             38 LOAD_CONST               3 (1)\n",
      "             40 BINARY_SUBTRACT\n",
      "             42 STORE_FAST               2 (depth)\n",
      "\n",
      "377     >>   44 LOAD_FAST                0 (co)\n",
      "             46 LOAD_ATTR                1 (co_consts)\n",
      "             48 GET_ITER\n",
      "        >>   50 FOR_ITER                56 (to 108)\n",
      "             52 STORE_FAST               3 (x)\n",
      "\n",
      "378          54 LOAD_GLOBAL              2 (hasattr)\n",
      "             56 LOAD_FAST                3 (x)\n",
      "             58 LOAD_CONST               4 ('co_code')\n",
      "             60 CALL_FUNCTION            2\n",
      "             62 POP_JUMP_IF_FALSE       50\n",
      "\n",
      "379          64 LOAD_GLOBAL              3 (print)\n",
      "             66 LOAD_FAST                1 (file)\n",
      "             68 LOAD_CONST               1 (('file',))\n",
      "             70 CALL_FUNCTION_KW         1\n",
      "             72 POP_TOP\n",
      "\n",
      "380          74 LOAD_GLOBAL              3 (print)\n",
      "             76 LOAD_CONST               5 ('Disassembly of %r:')\n",
      "             78 LOAD_FAST                3 (x)\n",
      "             80 BUILD_TUPLE              1\n",
      "             82 BINARY_MODULO\n",
      "             84 LOAD_FAST                1 (file)\n",
      "             86 LOAD_CONST               1 (('file',))\n",
      "             88 CALL_FUNCTION_KW         2\n",
      "             90 POP_TOP\n",
      "\n",
      "381          92 LOAD_GLOBAL              4 (_disassemble_recursive)\n",
      "             94 LOAD_FAST                3 (x)\n",
      "             96 LOAD_FAST                1 (file)\n",
      "             98 LOAD_FAST                2 (depth)\n",
      "            100 LOAD_CONST               6 (('file', 'depth'))\n",
      "            102 CALL_FUNCTION_KW         3\n",
      "            104 POP_TOP\n",
      "            106 JUMP_ABSOLUTE           50\n",
      "        >>  108 LOAD_CONST               0 (None)\n",
      "            110 RETURN_VALUE\n",
      "\n",
      "Disassembly of _disassemble_str:\n",
      "415           0 LOAD_GLOBAL              0 (_disassemble_recursive)\n",
      "              2 LOAD_GLOBAL              1 (_try_compile)\n",
      "              4 LOAD_FAST                0 (source)\n",
      "              6 LOAD_CONST               1 ('<dis>')\n",
      "              8 CALL_FUNCTION            2\n",
      "             10 BUILD_TUPLE              1\n",
      "             12 BUILD_MAP                0\n",
      "             14 LOAD_FAST                1 (kwargs)\n",
      "             16 DICT_MERGE               1\n",
      "             18 CALL_FUNCTION_EX         1\n",
      "             20 POP_TOP\n",
      "             22 LOAD_CONST               2 (None)\n",
      "             24 RETURN_VALUE\n",
      "\n",
      "Disassembly of _format_code_info:\n",
      "156           0 BUILD_LIST               0\n",
      "              2 STORE_FAST               1 (lines)\n",
      "\n",
      "157           4 LOAD_FAST                1 (lines)\n",
      "              6 LOAD_METHOD              0 (append)\n",
      "              8 LOAD_CONST               1 ('Name:              %s')\n",
      "             10 LOAD_FAST                0 (co)\n",
      "             12 LOAD_ATTR                1 (co_name)\n",
      "             14 BINARY_MODULO\n",
      "             16 CALL_METHOD              1\n",
      "             18 POP_TOP\n",
      "\n",
      "158          20 LOAD_FAST                1 (lines)\n",
      "             22 LOAD_METHOD              0 (append)\n",
      "             24 LOAD_CONST               2 ('Filename:          %s')\n",
      "             26 LOAD_FAST                0 (co)\n",
      "             28 LOAD_ATTR                2 (co_filename)\n",
      "             30 BINARY_MODULO\n",
      "             32 CALL_METHOD              1\n",
      "             34 POP_TOP\n",
      "\n",
      "159          36 LOAD_FAST                1 (lines)\n",
      "             38 LOAD_METHOD              0 (append)\n",
      "             40 LOAD_CONST               3 ('Argument count:    %s')\n",
      "             42 LOAD_FAST                0 (co)\n",
      "             44 LOAD_ATTR                3 (co_argcount)\n",
      "             46 BINARY_MODULO\n",
      "             48 CALL_METHOD              1\n",
      "             50 POP_TOP\n",
      "\n",
      "160          52 LOAD_FAST                1 (lines)\n",
      "             54 LOAD_METHOD              0 (append)\n",
      "             56 LOAD_CONST               4 ('Positional-only arguments: %s')\n",
      "             58 LOAD_FAST                0 (co)\n",
      "             60 LOAD_ATTR                4 (co_posonlyargcount)\n",
      "             62 BINARY_MODULO\n",
      "             64 CALL_METHOD              1\n",
      "             66 POP_TOP\n",
      "\n",
      "161          68 LOAD_FAST                1 (lines)\n",
      "             70 LOAD_METHOD              0 (append)\n",
      "             72 LOAD_CONST               5 ('Kw-only arguments: %s')\n",
      "             74 LOAD_FAST                0 (co)\n",
      "             76 LOAD_ATTR                5 (co_kwonlyargcount)\n",
      "             78 BINARY_MODULO\n",
      "             80 CALL_METHOD              1\n",
      "             82 POP_TOP\n",
      "\n",
      "162          84 LOAD_FAST                1 (lines)\n",
      "             86 LOAD_METHOD              0 (append)\n",
      "             88 LOAD_CONST               6 ('Number of locals:  %s')\n",
      "             90 LOAD_FAST                0 (co)\n",
      "             92 LOAD_ATTR                6 (co_nlocals)\n",
      "             94 BINARY_MODULO\n",
      "             96 CALL_METHOD              1\n",
      "             98 POP_TOP\n",
      "\n",
      "163         100 LOAD_FAST                1 (lines)\n",
      "            102 LOAD_METHOD              0 (append)\n",
      "            104 LOAD_CONST               7 ('Stack size:        %s')\n",
      "            106 LOAD_FAST                0 (co)\n",
      "            108 LOAD_ATTR                7 (co_stacksize)\n",
      "            110 BINARY_MODULO\n",
      "            112 CALL_METHOD              1\n",
      "            114 POP_TOP\n",
      "\n",
      "164         116 LOAD_FAST                1 (lines)\n",
      "            118 LOAD_METHOD              0 (append)\n",
      "            120 LOAD_CONST               8 ('Flags:             %s')\n",
      "            122 LOAD_GLOBAL              8 (pretty_flags)\n",
      "            124 LOAD_FAST                0 (co)\n",
      "            126 LOAD_ATTR                9 (co_flags)\n",
      "            128 CALL_FUNCTION            1\n",
      "            130 BINARY_MODULO\n",
      "            132 CALL_METHOD              1\n",
      "            134 POP_TOP\n",
      "\n",
      "165         136 LOAD_FAST                0 (co)\n",
      "            138 LOAD_ATTR               10 (co_consts)\n",
      "            140 POP_JUMP_IF_FALSE      182\n",
      "\n",
      "166         142 LOAD_FAST                1 (lines)\n",
      "            144 LOAD_METHOD              0 (append)\n",
      "            146 LOAD_CONST               9 ('Constants:')\n",
      "            148 CALL_METHOD              1\n",
      "            150 POP_TOP\n",
      "\n",
      "167         152 LOAD_GLOBAL             11 (enumerate)\n",
      "            154 LOAD_FAST                0 (co)\n",
      "            156 LOAD_ATTR               10 (co_consts)\n",
      "            158 CALL_FUNCTION            1\n",
      "            160 GET_ITER\n",
      "        >>  162 FOR_ITER                18 (to 182)\n",
      "            164 STORE_FAST               2 (i_c)\n",
      "\n",
      "168         166 LOAD_FAST                1 (lines)\n",
      "            168 LOAD_METHOD              0 (append)\n",
      "            170 LOAD_CONST              10 ('%4d: %r')\n",
      "            172 LOAD_FAST                2 (i_c)\n",
      "            174 BINARY_MODULO\n",
      "            176 CALL_METHOD              1\n",
      "            178 POP_TOP\n",
      "            180 JUMP_ABSOLUTE          162\n",
      "\n",
      "169     >>  182 LOAD_FAST                0 (co)\n",
      "            184 LOAD_ATTR               12 (co_names)\n",
      "            186 POP_JUMP_IF_FALSE      228\n",
      "\n",
      "170         188 LOAD_FAST                1 (lines)\n",
      "            190 LOAD_METHOD              0 (append)\n",
      "            192 LOAD_CONST              11 ('Names:')\n",
      "            194 CALL_METHOD              1\n",
      "            196 POP_TOP\n",
      "\n",
      "171         198 LOAD_GLOBAL             11 (enumerate)\n",
      "            200 LOAD_FAST                0 (co)\n",
      "            202 LOAD_ATTR               12 (co_names)\n",
      "            204 CALL_FUNCTION            1\n",
      "            206 GET_ITER\n",
      "        >>  208 FOR_ITER                18 (to 228)\n",
      "            210 STORE_FAST               3 (i_n)\n",
      "\n",
      "172         212 LOAD_FAST                1 (lines)\n",
      "            214 LOAD_METHOD              0 (append)\n",
      "            216 LOAD_CONST              12 ('%4d: %s')\n",
      "            218 LOAD_FAST                3 (i_n)\n",
      "            220 BINARY_MODULO\n",
      "            222 CALL_METHOD              1\n",
      "            224 POP_TOP\n",
      "            226 JUMP_ABSOLUTE          208\n",
      "\n",
      "173     >>  228 LOAD_FAST                0 (co)\n",
      "            230 LOAD_ATTR               13 (co_varnames)\n",
      "            232 EXTENDED_ARG             1\n",
      "            234 POP_JUMP_IF_FALSE      278\n",
      "\n",
      "174         236 LOAD_FAST                1 (lines)\n",
      "            238 LOAD_METHOD              0 (append)\n",
      "            240 LOAD_CONST              13 ('Variable names:')\n",
      "            242 CALL_METHOD              1\n",
      "            244 POP_TOP\n",
      "\n",
      "175         246 LOAD_GLOBAL             11 (enumerate)\n",
      "            248 LOAD_FAST                0 (co)\n",
      "            250 LOAD_ATTR               13 (co_varnames)\n",
      "            252 CALL_FUNCTION            1\n",
      "            254 GET_ITER\n",
      "        >>  256 FOR_ITER                20 (to 278)\n",
      "            258 STORE_FAST               3 (i_n)\n",
      "\n",
      "176         260 LOAD_FAST                1 (lines)\n",
      "            262 LOAD_METHOD              0 (append)\n",
      "            264 LOAD_CONST              12 ('%4d: %s')\n",
      "            266 LOAD_FAST                3 (i_n)\n",
      "            268 BINARY_MODULO\n",
      "            270 CALL_METHOD              1\n",
      "            272 POP_TOP\n",
      "            274 EXTENDED_ARG             1\n",
      "            276 JUMP_ABSOLUTE          256\n",
      "\n",
      "177     >>  278 LOAD_FAST                0 (co)\n",
      "            280 LOAD_ATTR               14 (co_freevars)\n",
      "            282 EXTENDED_ARG             1\n",
      "            284 POP_JUMP_IF_FALSE      328\n",
      "\n",
      "178         286 LOAD_FAST                1 (lines)\n",
      "            288 LOAD_METHOD              0 (append)\n",
      "            290 LOAD_CONST              14 ('Free variables:')\n",
      "            292 CALL_METHOD              1\n",
      "            294 POP_TOP\n",
      "\n",
      "179         296 LOAD_GLOBAL             11 (enumerate)\n",
      "            298 LOAD_FAST                0 (co)\n",
      "            300 LOAD_ATTR               14 (co_freevars)\n",
      "            302 CALL_FUNCTION            1\n",
      "            304 GET_ITER\n",
      "        >>  306 FOR_ITER                20 (to 328)\n",
      "            308 STORE_FAST               3 (i_n)\n",
      "\n",
      "180         310 LOAD_FAST                1 (lines)\n",
      "            312 LOAD_METHOD              0 (append)\n",
      "            314 LOAD_CONST              12 ('%4d: %s')\n",
      "            316 LOAD_FAST                3 (i_n)\n",
      "            318 BINARY_MODULO\n",
      "            320 CALL_METHOD              1\n",
      "            322 POP_TOP\n",
      "            324 EXTENDED_ARG             1\n",
      "            326 JUMP_ABSOLUTE          306\n",
      "\n",
      "181     >>  328 LOAD_FAST                0 (co)\n",
      "            330 LOAD_ATTR               15 (co_cellvars)\n",
      "            332 EXTENDED_ARG             1\n",
      "            334 POP_JUMP_IF_FALSE      378\n",
      "\n",
      "182         336 LOAD_FAST                1 (lines)\n",
      "            338 LOAD_METHOD              0 (append)\n",
      "            340 LOAD_CONST              15 ('Cell variables:')\n",
      "            342 CALL_METHOD              1\n",
      "            344 POP_TOP\n",
      "\n",
      "183         346 LOAD_GLOBAL             11 (enumerate)\n",
      "            348 LOAD_FAST                0 (co)\n",
      "            350 LOAD_ATTR               15 (co_cellvars)\n",
      "            352 CALL_FUNCTION            1\n",
      "            354 GET_ITER\n",
      "        >>  356 FOR_ITER                20 (to 378)\n",
      "            358 STORE_FAST               3 (i_n)\n",
      "\n",
      "184         360 LOAD_FAST                1 (lines)\n",
      "            362 LOAD_METHOD              0 (append)\n",
      "            364 LOAD_CONST              12 ('%4d: %s')\n",
      "            366 LOAD_FAST                3 (i_n)\n",
      "            368 BINARY_MODULO\n",
      "            370 CALL_METHOD              1\n",
      "            372 POP_TOP\n",
      "            374 EXTENDED_ARG             1\n",
      "            376 JUMP_ABSOLUTE          356\n",
      "\n",
      "185     >>  378 LOAD_CONST              16 ('\\n')\n",
      "            380 LOAD_METHOD             16 (join)\n",
      "            382 LOAD_FAST                1 (lines)\n",
      "            384 CALL_METHOD              1\n",
      "            386 RETURN_VALUE\n",
      "\n",
      "Disassembly of _get_code_object:\n",
      "131           0 LOAD_GLOBAL              0 (hasattr)\n",
      "              2 LOAD_FAST                0 (x)\n",
      "              4 LOAD_CONST               1 ('__func__')\n",
      "              6 CALL_FUNCTION            2\n",
      "              8 POP_JUMP_IF_FALSE       16\n",
      "\n",
      "132          10 LOAD_FAST                0 (x)\n",
      "             12 LOAD_ATTR                1 (__func__)\n",
      "             14 STORE_FAST               0 (x)\n",
      "\n",
      "134     >>   16 LOAD_GLOBAL              0 (hasattr)\n",
      "             18 LOAD_FAST                0 (x)\n",
      "             20 LOAD_CONST               2 ('__code__')\n",
      "             22 CALL_FUNCTION            2\n",
      "             24 POP_JUMP_IF_FALSE       34\n",
      "\n",
      "135          26 LOAD_FAST                0 (x)\n",
      "             28 LOAD_ATTR                2 (__code__)\n",
      "             30 STORE_FAST               0 (x)\n",
      "             32 JUMP_FORWARD            52 (to 86)\n",
      "\n",
      "136     >>   34 LOAD_GLOBAL              0 (hasattr)\n",
      "             36 LOAD_FAST                0 (x)\n",
      "             38 LOAD_CONST               3 ('gi_code')\n",
      "             40 CALL_FUNCTION            2\n",
      "             42 POP_JUMP_IF_FALSE       52\n",
      "\n",
      "137          44 LOAD_FAST                0 (x)\n",
      "             46 LOAD_ATTR                3 (gi_code)\n",
      "             48 STORE_FAST               0 (x)\n",
      "             50 JUMP_FORWARD            34 (to 86)\n",
      "\n",
      "138     >>   52 LOAD_GLOBAL              0 (hasattr)\n",
      "             54 LOAD_FAST                0 (x)\n",
      "             56 LOAD_CONST               4 ('ag_code')\n",
      "             58 CALL_FUNCTION            2\n",
      "             60 POP_JUMP_IF_FALSE       70\n",
      "\n",
      "139          62 LOAD_FAST                0 (x)\n",
      "             64 LOAD_ATTR                4 (ag_code)\n",
      "             66 STORE_FAST               0 (x)\n",
      "             68 JUMP_FORWARD            16 (to 86)\n",
      "\n",
      "140     >>   70 LOAD_GLOBAL              0 (hasattr)\n",
      "             72 LOAD_FAST                0 (x)\n",
      "             74 LOAD_CONST               5 ('cr_code')\n",
      "             76 CALL_FUNCTION            2\n",
      "             78 POP_JUMP_IF_FALSE       86\n",
      "\n",
      "141          80 LOAD_FAST                0 (x)\n",
      "             82 LOAD_ATTR                5 (cr_code)\n",
      "             84 STORE_FAST               0 (x)\n",
      "\n",
      "143     >>   86 LOAD_GLOBAL              6 (isinstance)\n",
      "             88 LOAD_FAST                0 (x)\n",
      "             90 LOAD_GLOBAL              7 (str)\n",
      "             92 CALL_FUNCTION            2\n",
      "             94 POP_JUMP_IF_FALSE      106\n",
      "\n",
      "144          96 LOAD_GLOBAL              8 (_try_compile)\n",
      "             98 LOAD_FAST                0 (x)\n",
      "            100 LOAD_CONST               6 ('<disassembly>')\n",
      "            102 CALL_FUNCTION            2\n",
      "            104 STORE_FAST               0 (x)\n",
      "\n",
      "146     >>  106 LOAD_GLOBAL              0 (hasattr)\n",
      "            108 LOAD_FAST                0 (x)\n",
      "            110 LOAD_CONST               7 ('co_code')\n",
      "            112 CALL_FUNCTION            2\n",
      "            114 POP_JUMP_IF_FALSE      120\n",
      "\n",
      "147         116 LOAD_FAST                0 (x)\n",
      "            118 RETURN_VALUE\n",
      "\n",
      "148     >>  120 LOAD_GLOBAL              9 (TypeError)\n",
      "            122 LOAD_CONST               8 (\"don't know how to disassemble %s objects\")\n",
      "\n",
      "149         124 LOAD_GLOBAL             10 (type)\n",
      "            126 LOAD_FAST                0 (x)\n",
      "            128 CALL_FUNCTION            1\n",
      "            130 LOAD_ATTR               11 (__name__)\n",
      "\n",
      "148         132 BINARY_MODULO\n",
      "            134 CALL_FUNCTION            1\n",
      "            136 RAISE_VARARGS            1\n",
      "            138 LOAD_CONST               9 (None)\n",
      "            140 RETURN_VALUE\n",
      "\n",
      "Disassembly of _get_const_info:\n",
      "290           0 LOAD_FAST                0 (const_index)\n",
      "              2 STORE_FAST               2 (argval)\n",
      "\n",
      "291           4 LOAD_FAST                1 (const_list)\n",
      "              6 LOAD_CONST               1 (None)\n",
      "              8 IS_OP                    1\n",
      "             10 POP_JUMP_IF_FALSE       20\n",
      "\n",
      "292          12 LOAD_FAST                1 (const_list)\n",
      "             14 LOAD_FAST                0 (const_index)\n",
      "             16 BINARY_SUBSCR\n",
      "             18 STORE_FAST               2 (argval)\n",
      "\n",
      "293     >>   20 LOAD_FAST                2 (argval)\n",
      "             22 LOAD_GLOBAL              0 (repr)\n",
      "             24 LOAD_FAST                2 (argval)\n",
      "             26 CALL_FUNCTION            1\n",
      "             28 BUILD_TUPLE              2\n",
      "             30 RETURN_VALUE\n",
      "\n",
      "Disassembly of _get_instructions_bytes:\n",
      "321           0 LOAD_GLOBAL              0 (findlabels)\n",
      "              2 LOAD_FAST                0 (code)\n",
      "              4 CALL_FUNCTION            1\n",
      "              6 STORE_FAST               7 (labels)\n",
      "\n",
      "322           8 LOAD_CONST               1 (None)\n",
      "             10 STORE_FAST               8 (starts_line)\n",
      "\n",
      "323          12 LOAD_GLOBAL              1 (_unpack_opargs)\n",
      "             14 LOAD_FAST                0 (code)\n",
      "             16 CALL_FUNCTION            1\n",
      "             18 GET_ITER\n",
      "        >>   20 EXTENDED_ARG             1\n",
      "             22 FOR_ITER               370 (to 394)\n",
      "             24 UNPACK_SEQUENCE          3\n",
      "             26 STORE_FAST               9 (offset)\n",
      "             28 STORE_FAST              10 (op)\n",
      "             30 STORE_DEREF              0 (arg)\n",
      "\n",
      "324          32 LOAD_FAST                5 (linestarts)\n",
      "             34 LOAD_CONST               1 (None)\n",
      "             36 IS_OP                    1\n",
      "             38 POP_JUMP_IF_FALSE       68\n",
      "\n",
      "325          40 LOAD_FAST                5 (linestarts)\n",
      "             42 LOAD_METHOD              2 (get)\n",
      "             44 LOAD_FAST                9 (offset)\n",
      "             46 LOAD_CONST               1 (None)\n",
      "             48 CALL_METHOD              2\n",
      "             50 STORE_FAST               8 (starts_line)\n",
      "\n",
      "326          52 LOAD_FAST                8 (starts_line)\n",
      "             54 LOAD_CONST               1 (None)\n",
      "             56 IS_OP                    1\n",
      "             58 POP_JUMP_IF_FALSE       68\n",
      "\n",
      "327          60 LOAD_FAST                8 (starts_line)\n",
      "             62 LOAD_FAST                6 (line_offset)\n",
      "             64 INPLACE_ADD\n",
      "             66 STORE_FAST               8 (starts_line)\n",
      "\n",
      "328     >>   68 LOAD_FAST                9 (offset)\n",
      "             70 LOAD_FAST                7 (labels)\n",
      "             72 CONTAINS_OP              0\n",
      "             74 STORE_FAST              11 (is_jump_target)\n",
      "\n",
      "329          76 LOAD_CONST               1 (None)\n",
      "             78 STORE_FAST              12 (argval)\n",
      "\n",
      "330          80 LOAD_CONST               2 ('')\n",
      "             82 STORE_FAST              13 (argrepr)\n",
      "\n",
      "331          84 LOAD_DEREF               0 (arg)\n",
      "             86 LOAD_CONST               1 (None)\n",
      "             88 IS_OP                    1\n",
      "             90 EXTENDED_ARG             1\n",
      "             92 POP_JUMP_IF_FALSE      364\n",
      "\n",
      "336          94 LOAD_DEREF               0 (arg)\n",
      "             96 STORE_FAST              12 (argval)\n",
      "\n",
      "337          98 LOAD_FAST               10 (op)\n",
      "            100 LOAD_GLOBAL              3 (hasconst)\n",
      "            102 CONTAINS_OP              0\n",
      "            104 POP_JUMP_IF_FALSE      122\n",
      "\n",
      "338         106 LOAD_GLOBAL              4 (_get_const_info)\n",
      "            108 LOAD_DEREF               0 (arg)\n",
      "            110 LOAD_FAST                3 (constants)\n",
      "            112 CALL_FUNCTION            2\n",
      "            114 UNPACK_SEQUENCE          2\n",
      "            116 STORE_FAST              12 (argval)\n",
      "            118 STORE_FAST              13 (argrepr)\n",
      "            120 JUMP_FORWARD           242 (to 364)\n",
      "\n",
      "339     >>  122 LOAD_FAST               10 (op)\n",
      "            124 LOAD_GLOBAL              5 (hasname)\n",
      "            126 CONTAINS_OP              0\n",
      "            128 POP_JUMP_IF_FALSE      146\n",
      "\n",
      "340         130 LOAD_GLOBAL              6 (_get_name_info)\n",
      "            132 LOAD_DEREF               0 (arg)\n",
      "            134 LOAD_FAST                2 (names)\n",
      "            136 CALL_FUNCTION            2\n",
      "            138 UNPACK_SEQUENCE          2\n",
      "            140 STORE_FAST              12 (argval)\n",
      "            142 STORE_FAST              13 (argrepr)\n",
      "            144 JUMP_FORWARD           218 (to 364)\n",
      "\n",
      "341     >>  146 LOAD_FAST               10 (op)\n",
      "            148 LOAD_GLOBAL              7 (hasjrel)\n",
      "            150 CONTAINS_OP              0\n",
      "            152 POP_JUMP_IF_FALSE      180\n",
      "\n",
      "342         154 LOAD_FAST                9 (offset)\n",
      "            156 LOAD_CONST               3 (2)\n",
      "            158 BINARY_ADD\n",
      "            160 LOAD_DEREF               0 (arg)\n",
      "            162 BINARY_ADD\n",
      "            164 STORE_FAST              12 (argval)\n",
      "\n",
      "343         166 LOAD_CONST               4 ('to ')\n",
      "            168 LOAD_GLOBAL              8 (repr)\n",
      "            170 LOAD_FAST               12 (argval)\n",
      "            172 CALL_FUNCTION            1\n",
      "            174 BINARY_ADD\n",
      "            176 STORE_FAST              13 (argrepr)\n",
      "            178 JUMP_FORWARD           184 (to 364)\n",
      "\n",
      "344     >>  180 LOAD_FAST               10 (op)\n",
      "            182 LOAD_GLOBAL              9 (haslocal)\n",
      "            184 CONTAINS_OP              0\n",
      "            186 POP_JUMP_IF_FALSE      204\n",
      "\n",
      "345         188 LOAD_GLOBAL              6 (_get_name_info)\n",
      "            190 LOAD_DEREF               0 (arg)\n",
      "            192 LOAD_FAST                1 (varnames)\n",
      "            194 CALL_FUNCTION            2\n",
      "            196 UNPACK_SEQUENCE          2\n",
      "            198 STORE_FAST              12 (argval)\n",
      "            200 STORE_FAST              13 (argrepr)\n",
      "            202 JUMP_FORWARD           160 (to 364)\n",
      "\n",
      "346     >>  204 LOAD_FAST               10 (op)\n",
      "            206 LOAD_GLOBAL             10 (hascompare)\n",
      "            208 CONTAINS_OP              0\n",
      "            210 POP_JUMP_IF_FALSE      226\n",
      "\n",
      "347         212 LOAD_GLOBAL             11 (cmp_op)\n",
      "            214 LOAD_DEREF               0 (arg)\n",
      "            216 BINARY_SUBSCR\n",
      "            218 STORE_FAST              12 (argval)\n",
      "\n",
      "348         220 LOAD_FAST               12 (argval)\n",
      "            222 STORE_FAST              13 (argrepr)\n",
      "            224 JUMP_FORWARD           138 (to 364)\n",
      "\n",
      "349     >>  226 LOAD_FAST               10 (op)\n",
      "            228 LOAD_GLOBAL             12 (hasfree)\n",
      "            230 CONTAINS_OP              0\n",
      "            232 POP_JUMP_IF_FALSE      250\n",
      "\n",
      "350         234 LOAD_GLOBAL              6 (_get_name_info)\n",
      "            236 LOAD_DEREF               0 (arg)\n",
      "            238 LOAD_FAST                4 (cells)\n",
      "            240 CALL_FUNCTION            2\n",
      "            242 UNPACK_SEQUENCE          2\n",
      "            244 STORE_FAST              12 (argval)\n",
      "            246 STORE_FAST              13 (argrepr)\n",
      "            248 JUMP_FORWARD           114 (to 364)\n",
      "\n",
      "351     >>  250 LOAD_FAST               10 (op)\n",
      "            252 LOAD_GLOBAL             13 (FORMAT_VALUE)\n",
      "            254 COMPARE_OP               2 (==)\n",
      "            256 EXTENDED_ARG             1\n",
      "            258 POP_JUMP_IF_FALSE      326\n",
      "\n",
      "352         260 LOAD_GLOBAL             14 (FORMAT_VALUE_CONVERTERS)\n",
      "            262 LOAD_DEREF               0 (arg)\n",
      "            264 LOAD_CONST               5 (3)\n",
      "            266 BINARY_AND\n",
      "            268 BINARY_SUBSCR\n",
      "            270 UNPACK_SEQUENCE          2\n",
      "            272 STORE_FAST              12 (argval)\n",
      "            274 STORE_FAST              13 (argrepr)\n",
      "\n",
      "353         276 LOAD_FAST               12 (argval)\n",
      "            278 LOAD_GLOBAL             15 (bool)\n",
      "            280 LOAD_DEREF               0 (arg)\n",
      "            282 LOAD_CONST               6 (4)\n",
      "            284 BINARY_AND\n",
      "            286 CALL_FUNCTION            1\n",
      "            288 BUILD_TUPLE              2\n",
      "            290 STORE_FAST              12 (argval)\n",
      "\n",
      "354         292 LOAD_FAST               12 (argval)\n",
      "            294 LOAD_CONST               7 (1)\n",
      "            296 BINARY_SUBSCR\n",
      "            298 EXTENDED_ARG             1\n",
      "            300 POP_JUMP_IF_FALSE      364\n",
      "\n",
      "355         302 LOAD_FAST               13 (argrepr)\n",
      "            304 EXTENDED_ARG             1\n",
      "            306 POP_JUMP_IF_FALSE      316\n",
      "\n",
      "356         308 LOAD_FAST               13 (argrepr)\n",
      "            310 LOAD_CONST               8 (', ')\n",
      "            312 INPLACE_ADD\n",
      "            314 STORE_FAST              13 (argrepr)\n",
      "\n",
      "357     >>  316 LOAD_FAST               13 (argrepr)\n",
      "            318 LOAD_CONST               9 ('with format')\n",
      "            320 INPLACE_ADD\n",
      "            322 STORE_FAST              13 (argrepr)\n",
      "            324 JUMP_FORWARD            38 (to 364)\n",
      "\n",
      "358     >>  326 LOAD_FAST               10 (op)\n",
      "            328 LOAD_GLOBAL             16 (MAKE_FUNCTION)\n",
      "            330 COMPARE_OP               2 (==)\n",
      "            332 EXTENDED_ARG             1\n",
      "            334 POP_JUMP_IF_FALSE      364\n",
      "\n",
      "359         336 LOAD_CONST               8 (', ')\n",
      "            338 LOAD_METHOD             17 (join)\n",
      "            340 LOAD_CLOSURE             0 (arg)\n",
      "            342 BUILD_TUPLE              1\n",
      "            344 LOAD_CONST              10 (<code object <genexpr> at 0x7fcdd5ab9a80, file \"/opt/anaconda3/envs/trainingAI/lib/python3.9/dis.py\", line 359>)\n",
      "            346 LOAD_CONST              11 ('_get_instructions_bytes.<locals>.<genexpr>')\n",
      "            348 MAKE_FUNCTION            8 (closure)\n",
      "            350 LOAD_GLOBAL             18 (enumerate)\n",
      "            352 LOAD_GLOBAL             19 (MAKE_FUNCTION_FLAGS)\n",
      "            354 CALL_FUNCTION            1\n",
      "            356 GET_ITER\n",
      "            358 CALL_FUNCTION            1\n",
      "            360 CALL_METHOD              1\n",
      "            362 STORE_FAST              13 (argrepr)\n",
      "\n",
      "361     >>  364 LOAD_GLOBAL             20 (Instruction)\n",
      "            366 LOAD_GLOBAL             21 (opname)\n",
      "            368 LOAD_FAST               10 (op)\n",
      "            370 BINARY_SUBSCR\n",
      "            372 LOAD_FAST               10 (op)\n",
      "\n",
      "362         374 LOAD_DEREF               0 (arg)\n",
      "            376 LOAD_FAST               12 (argval)\n",
      "            378 LOAD_FAST               13 (argrepr)\n",
      "\n",
      "363         380 LOAD_FAST                9 (offset)\n",
      "            382 LOAD_FAST                8 (starts_line)\n",
      "            384 LOAD_FAST               11 (is_jump_target)\n",
      "\n",
      "361         386 CALL_FUNCTION            8\n",
      "            388 YIELD_VALUE\n",
      "            390 POP_TOP\n",
      "            392 JUMP_ABSOLUTE           20\n",
      "        >>  394 LOAD_CONST               1 (None)\n",
      "            396 RETURN_VALUE\n",
      "\n",
      "Disassembly of <code object <genexpr> at 0x7fcdd5ab9a80, file \"/opt/anaconda3/envs/trainingAI/lib/python3.9/dis.py\", line 359>:\n",
      "359           0 LOAD_FAST                0 (.0)\n",
      "        >>    2 FOR_ITER                26 (to 30)\n",
      "              4 UNPACK_SEQUENCE          2\n",
      "              6 STORE_FAST               1 (i)\n",
      "              8 STORE_FAST               2 (s)\n",
      "\n",
      "360          10 LOAD_DEREF               0 (arg)\n",
      "             12 LOAD_CONST               0 (1)\n",
      "             14 LOAD_FAST                1 (i)\n",
      "             16 BINARY_LSHIFT\n",
      "             18 BINARY_AND\n",
      "             20 POP_JUMP_IF_FALSE        2\n",
      "\n",
      "359          22 LOAD_FAST                2 (s)\n",
      "             24 YIELD_VALUE\n",
      "             26 POP_TOP\n",
      "             28 JUMP_ABSOLUTE            2\n",
      "        >>   30 LOAD_CONST               1 (None)\n",
      "             32 RETURN_VALUE\n",
      "\n",
      "Disassembly of _get_name_info:\n",
      "302           0 LOAD_FAST                0 (name_index)\n",
      "              2 STORE_FAST               2 (argval)\n",
      "\n",
      "303           4 LOAD_FAST                1 (name_list)\n",
      "              6 LOAD_CONST               1 (None)\n",
      "              8 IS_OP                    1\n",
      "             10 POP_JUMP_IF_FALSE       26\n",
      "\n",
      "304          12 LOAD_FAST                1 (name_list)\n",
      "             14 LOAD_FAST                0 (name_index)\n",
      "             16 BINARY_SUBSCR\n",
      "             18 STORE_FAST               2 (argval)\n",
      "\n",
      "305          20 LOAD_FAST                2 (argval)\n",
      "             22 STORE_FAST               3 (argrepr)\n",
      "             24 JUMP_FORWARD             8 (to 34)\n",
      "\n",
      "307     >>   26 LOAD_GLOBAL              0 (repr)\n",
      "             28 LOAD_FAST                2 (argval)\n",
      "             30 CALL_FUNCTION            1\n",
      "             32 STORE_FAST               3 (argrepr)\n",
      "\n",
      "308     >>   34 LOAD_FAST                2 (argval)\n",
      "             36 LOAD_FAST                3 (argrepr)\n",
      "             38 BUILD_TUPLE              2\n",
      "             40 RETURN_VALUE\n",
      "\n",
      "Disassembly of _test:\n",
      "542           0 LOAD_CONST               1 (0)\n",
      "              2 LOAD_CONST               2 (None)\n",
      "              4 IMPORT_NAME              0 (argparse)\n",
      "              6 STORE_FAST               0 (argparse)\n",
      "\n",
      "544           8 LOAD_FAST                0 (argparse)\n",
      "             10 LOAD_METHOD              1 (ArgumentParser)\n",
      "             12 CALL_METHOD              0\n",
      "             14 STORE_FAST               1 (parser)\n",
      "\n",
      "545          16 LOAD_FAST                1 (parser)\n",
      "             18 LOAD_ATTR                2 (add_argument)\n",
      "             20 LOAD_CONST               3 ('infile')\n",
      "             22 LOAD_FAST                0 (argparse)\n",
      "             24 LOAD_METHOD              3 (FileType)\n",
      "             26 LOAD_CONST               4 ('rb')\n",
      "             28 CALL_METHOD              1\n",
      "             30 LOAD_CONST               5 ('?')\n",
      "             32 LOAD_CONST               6 ('-')\n",
      "             34 LOAD_CONST               7 (('type', 'nargs', 'default'))\n",
      "             36 CALL_FUNCTION_KW         4\n",
      "             38 POP_TOP\n",
      "\n",
      "546          40 LOAD_FAST                1 (parser)\n",
      "             42 LOAD_METHOD              4 (parse_args)\n",
      "             44 CALL_METHOD              0\n",
      "             46 STORE_FAST               2 (args)\n",
      "\n",
      "547          48 LOAD_FAST                2 (args)\n",
      "             50 LOAD_ATTR                5 (infile)\n",
      "             52 SETUP_WITH              24 (to 78)\n",
      "             54 STORE_FAST               3 (infile)\n",
      "\n",
      "548          56 LOAD_FAST                3 (infile)\n",
      "             58 LOAD_METHOD              6 (read)\n",
      "             60 CALL_METHOD              0\n",
      "             62 STORE_FAST               4 (source)\n",
      "             64 POP_BLOCK\n",
      "             66 LOAD_CONST               2 (None)\n",
      "             68 DUP_TOP\n",
      "             70 DUP_TOP\n",
      "             72 CALL_FUNCTION            3\n",
      "             74 POP_TOP\n",
      "             76 JUMP_FORWARD            16 (to 94)\n",
      "        >>   78 WITH_EXCEPT_START\n",
      "             80 POP_JUMP_IF_TRUE        84\n",
      "             82 RERAISE\n",
      "        >>   84 POP_TOP\n",
      "             86 POP_TOP\n",
      "             88 POP_TOP\n",
      "             90 POP_EXCEPT\n",
      "             92 POP_TOP\n",
      "\n",
      "549     >>   94 LOAD_GLOBAL              7 (compile)\n",
      "             96 LOAD_FAST                4 (source)\n",
      "             98 LOAD_FAST                2 (args)\n",
      "            100 LOAD_ATTR                5 (infile)\n",
      "            102 LOAD_ATTR                8 (name)\n",
      "            104 LOAD_CONST               8 ('exec')\n",
      "            106 CALL_FUNCTION            3\n",
      "            108 STORE_FAST               5 (code)\n",
      "\n",
      "550         110 LOAD_GLOBAL              9 (dis)\n",
      "            112 LOAD_FAST                5 (code)\n",
      "            114 CALL_FUNCTION            1\n",
      "            116 POP_TOP\n",
      "            118 LOAD_CONST               2 (None)\n",
      "            120 RETURN_VALUE\n",
      "\n",
      "Disassembly of _try_compile:\n",
      " 37           0 SETUP_FINALLY           16 (to 18)\n",
      "\n",
      " 38           2 LOAD_GLOBAL              0 (compile)\n",
      "              4 LOAD_FAST                0 (source)\n",
      "              6 LOAD_FAST                1 (name)\n",
      "              8 LOAD_CONST               1 ('eval')\n",
      "             10 CALL_FUNCTION            3\n",
      "             12 STORE_FAST               2 (c)\n",
      "             14 POP_BLOCK\n",
      "             16 JUMP_FORWARD            30 (to 48)\n",
      "\n",
      " 39     >>   18 DUP_TOP\n",
      "             20 LOAD_GLOBAL              1 (SyntaxError)\n",
      "             22 JUMP_IF_NOT_EXC_MATCH    46\n",
      "             24 POP_TOP\n",
      "             26 POP_TOP\n",
      "             28 POP_TOP\n",
      "\n",
      " 40          30 LOAD_GLOBAL              0 (compile)\n",
      "             32 LOAD_FAST                0 (source)\n",
      "             34 LOAD_FAST                1 (name)\n",
      "             36 LOAD_CONST               2 ('exec')\n",
      "             38 CALL_FUNCTION            3\n",
      "             40 STORE_FAST               2 (c)\n",
      "             42 POP_EXCEPT\n",
      "             44 JUMP_FORWARD             2 (to 48)\n",
      "        >>   46 RERAISE\n",
      "\n",
      " 41     >>   48 LOAD_FAST                2 (c)\n",
      "             50 RETURN_VALUE\n",
      "\n",
      "Disassembly of _unpack_opargs:\n",
      "420           0 LOAD_CONST               1 (0)\n",
      "              2 STORE_FAST               1 (extended_arg)\n",
      "\n",
      "421           4 LOAD_GLOBAL              0 (range)\n",
      "              6 LOAD_CONST               1 (0)\n",
      "              8 LOAD_GLOBAL              1 (len)\n",
      "             10 LOAD_FAST                0 (code)\n",
      "             12 CALL_FUNCTION            1\n",
      "             14 LOAD_CONST               2 (2)\n",
      "             16 CALL_FUNCTION            3\n",
      "             18 GET_ITER\n",
      "        >>   20 FOR_ITER                74 (to 96)\n",
      "             22 STORE_FAST               2 (i)\n",
      "\n",
      "422          24 LOAD_FAST                0 (code)\n",
      "             26 LOAD_FAST                2 (i)\n",
      "             28 BINARY_SUBSCR\n",
      "             30 STORE_FAST               3 (op)\n",
      "\n",
      "423          32 LOAD_FAST                3 (op)\n",
      "             34 LOAD_GLOBAL              2 (HAVE_ARGUMENT)\n",
      "             36 COMPARE_OP               5 (>=)\n",
      "             38 POP_JUMP_IF_FALSE       78\n",
      "\n",
      "424          40 LOAD_FAST                0 (code)\n",
      "             42 LOAD_FAST                2 (i)\n",
      "             44 LOAD_CONST               3 (1)\n",
      "             46 BINARY_ADD\n",
      "             48 BINARY_SUBSCR\n",
      "             50 LOAD_FAST                1 (extended_arg)\n",
      "             52 BINARY_OR\n",
      "             54 STORE_FAST               4 (arg)\n",
      "\n",
      "425          56 LOAD_FAST                3 (op)\n",
      "             58 LOAD_GLOBAL              3 (EXTENDED_ARG)\n",
      "             60 COMPARE_OP               2 (==)\n",
      "             62 POP_JUMP_IF_FALSE       72\n",
      "             64 LOAD_FAST                4 (arg)\n",
      "             66 LOAD_CONST               4 (8)\n",
      "             68 BINARY_LSHIFT\n",
      "             70 JUMP_FORWARD             2 (to 74)\n",
      "        >>   72 LOAD_CONST               1 (0)\n",
      "        >>   74 STORE_FAST               1 (extended_arg)\n",
      "             76 JUMP_FORWARD             4 (to 82)\n",
      "\n",
      "427     >>   78 LOAD_CONST               0 (None)\n",
      "             80 STORE_FAST               4 (arg)\n",
      "\n",
      "428     >>   82 LOAD_FAST                2 (i)\n",
      "             84 LOAD_FAST                3 (op)\n",
      "             86 LOAD_FAST                4 (arg)\n",
      "             88 BUILD_TUPLE              3\n",
      "             90 YIELD_VALUE\n",
      "             92 POP_TOP\n",
      "             94 JUMP_ABSOLUTE           20\n",
      "        >>   96 LOAD_CONST               0 (None)\n",
      "             98 RETURN_VALUE\n",
      "\n",
      "Disassembly of code_info:\n",
      "153           0 LOAD_GLOBAL              0 (_format_code_info)\n",
      "              2 LOAD_GLOBAL              1 (_get_code_object)\n",
      "              4 LOAD_FAST                0 (x)\n",
      "              6 CALL_FUNCTION            1\n",
      "              8 CALL_FUNCTION            1\n",
      "             10 RETURN_VALUE\n",
      "\n",
      "Disassembly of dis:\n",
      " 52           0 LOAD_FAST                0 (x)\n",
      "              2 LOAD_CONST               1 (None)\n",
      "              4 IS_OP                    0\n",
      "              6 POP_JUMP_IF_FALSE       22\n",
      "\n",
      " 53           8 LOAD_GLOBAL              0 (distb)\n",
      "             10 LOAD_FAST                1 (file)\n",
      "             12 LOAD_CONST               2 (('file',))\n",
      "             14 CALL_FUNCTION_KW         1\n",
      "             16 POP_TOP\n",
      "\n",
      " 54          18 LOAD_CONST               1 (None)\n",
      "             20 RETURN_VALUE\n",
      "\n",
      " 56     >>   22 LOAD_GLOBAL              1 (hasattr)\n",
      "             24 LOAD_FAST                0 (x)\n",
      "             26 LOAD_CONST               3 ('__func__')\n",
      "             28 CALL_FUNCTION            2\n",
      "             30 POP_JUMP_IF_FALSE       38\n",
      "\n",
      " 57          32 LOAD_FAST                0 (x)\n",
      "             34 LOAD_ATTR                2 (__func__)\n",
      "             36 STORE_FAST               0 (x)\n",
      "\n",
      " 59     >>   38 LOAD_GLOBAL              1 (hasattr)\n",
      "             40 LOAD_FAST                0 (x)\n",
      "             42 LOAD_CONST               4 ('__code__')\n",
      "             44 CALL_FUNCTION            2\n",
      "             46 POP_JUMP_IF_FALSE       56\n",
      "\n",
      " 60          48 LOAD_FAST                0 (x)\n",
      "             50 LOAD_ATTR                3 (__code__)\n",
      "             52 STORE_FAST               0 (x)\n",
      "             54 JUMP_FORWARD            52 (to 108)\n",
      "\n",
      " 61     >>   56 LOAD_GLOBAL              1 (hasattr)\n",
      "             58 LOAD_FAST                0 (x)\n",
      "             60 LOAD_CONST               5 ('gi_code')\n",
      "             62 CALL_FUNCTION            2\n",
      "             64 POP_JUMP_IF_FALSE       74\n",
      "\n",
      " 62          66 LOAD_FAST                0 (x)\n",
      "             68 LOAD_ATTR                4 (gi_code)\n",
      "             70 STORE_FAST               0 (x)\n",
      "             72 JUMP_FORWARD            34 (to 108)\n",
      "\n",
      " 63     >>   74 LOAD_GLOBAL              1 (hasattr)\n",
      "             76 LOAD_FAST                0 (x)\n",
      "             78 LOAD_CONST               6 ('ag_code')\n",
      "             80 CALL_FUNCTION            2\n",
      "             82 POP_JUMP_IF_FALSE       92\n",
      "\n",
      " 64          84 LOAD_FAST                0 (x)\n",
      "             86 LOAD_ATTR                5 (ag_code)\n",
      "             88 STORE_FAST               0 (x)\n",
      "             90 JUMP_FORWARD            16 (to 108)\n",
      "\n",
      " 65     >>   92 LOAD_GLOBAL              1 (hasattr)\n",
      "             94 LOAD_FAST                0 (x)\n",
      "             96 LOAD_CONST               7 ('cr_code')\n",
      "             98 CALL_FUNCTION            2\n",
      "            100 POP_JUMP_IF_FALSE      108\n",
      "\n",
      " 66         102 LOAD_FAST                0 (x)\n",
      "            104 LOAD_ATTR                6 (cr_code)\n",
      "            106 STORE_FAST               0 (x)\n",
      "\n",
      " 68     >>  108 LOAD_GLOBAL              1 (hasattr)\n",
      "            110 LOAD_FAST                0 (x)\n",
      "            112 LOAD_CONST               8 ('__dict__')\n",
      "            114 CALL_FUNCTION            2\n",
      "            116 POP_JUMP_IF_FALSE      254\n",
      "\n",
      " 69         118 LOAD_GLOBAL              7 (sorted)\n",
      "            120 LOAD_FAST                0 (x)\n",
      "            122 LOAD_ATTR                8 (__dict__)\n",
      "            124 LOAD_METHOD              9 (items)\n",
      "            126 CALL_METHOD              0\n",
      "            128 CALL_FUNCTION            1\n",
      "            130 STORE_FAST               3 (items)\n",
      "\n",
      " 70         132 LOAD_FAST                3 (items)\n",
      "            134 GET_ITER\n",
      "        >>  136 FOR_ITER               114 (to 252)\n",
      "            138 UNPACK_SEQUENCE          2\n",
      "            140 STORE_FAST               4 (name)\n",
      "            142 STORE_FAST               5 (x1)\n",
      "\n",
      " 71         144 LOAD_GLOBAL             10 (isinstance)\n",
      "            146 LOAD_FAST                5 (x1)\n",
      "            148 LOAD_GLOBAL             11 (_have_code)\n",
      "            150 CALL_FUNCTION            2\n",
      "            152 POP_JUMP_IF_FALSE      136\n",
      "\n",
      " 72         154 LOAD_GLOBAL             12 (print)\n",
      "            156 LOAD_CONST               9 ('Disassembly of %s:')\n",
      "            158 LOAD_FAST                4 (name)\n",
      "            160 BINARY_MODULO\n",
      "            162 LOAD_FAST                1 (file)\n",
      "            164 LOAD_CONST               2 (('file',))\n",
      "            166 CALL_FUNCTION_KW         2\n",
      "            168 POP_TOP\n",
      "\n",
      " 73         170 SETUP_FINALLY           18 (to 190)\n",
      "\n",
      " 74         172 LOAD_GLOBAL             13 (dis)\n",
      "            174 LOAD_FAST                5 (x1)\n",
      "            176 LOAD_FAST                1 (file)\n",
      "            178 LOAD_FAST                2 (depth)\n",
      "            180 LOAD_CONST              10 (('file', 'depth'))\n",
      "            182 CALL_FUNCTION_KW         3\n",
      "            184 POP_TOP\n",
      "            186 POP_BLOCK\n",
      "            188 JUMP_FORWARD            50 (to 240)\n",
      "\n",
      " 75     >>  190 DUP_TOP\n",
      "            192 LOAD_GLOBAL             14 (TypeError)\n",
      "            194 JUMP_IF_NOT_EXC_MATCH   238\n",
      "            196 POP_TOP\n",
      "            198 STORE_FAST               6 (msg)\n",
      "            200 POP_TOP\n",
      "            202 SETUP_FINALLY           26 (to 230)\n",
      "\n",
      " 76         204 LOAD_GLOBAL             12 (print)\n",
      "            206 LOAD_CONST              11 ('Sorry:')\n",
      "            208 LOAD_FAST                6 (msg)\n",
      "            210 LOAD_FAST                1 (file)\n",
      "            212 LOAD_CONST               2 (('file',))\n",
      "            214 CALL_FUNCTION_KW         3\n",
      "            216 POP_TOP\n",
      "            218 POP_BLOCK\n",
      "            220 POP_EXCEPT\n",
      "            222 LOAD_CONST               1 (None)\n",
      "            224 STORE_FAST               6 (msg)\n",
      "            226 DELETE_FAST              6 (msg)\n",
      "            228 JUMP_FORWARD            10 (to 240)\n",
      "        >>  230 LOAD_CONST               1 (None)\n",
      "            232 STORE_FAST               6 (msg)\n",
      "            234 DELETE_FAST              6 (msg)\n",
      "            236 RERAISE\n",
      "        >>  238 RERAISE\n",
      "\n",
      " 77     >>  240 LOAD_GLOBAL             12 (print)\n",
      "            242 LOAD_FAST                1 (file)\n",
      "            244 LOAD_CONST               2 (('file',))\n",
      "            246 CALL_FUNCTION_KW         1\n",
      "            248 POP_TOP\n",
      "            250 JUMP_ABSOLUTE          136\n",
      "        >>  252 JUMP_FORWARD           104 (to 358)\n",
      "\n",
      " 78     >>  254 LOAD_GLOBAL              1 (hasattr)\n",
      "            256 LOAD_FAST                0 (x)\n",
      "            258 LOAD_CONST              12 ('co_code')\n",
      "            260 CALL_FUNCTION            2\n",
      "            262 EXTENDED_ARG             1\n",
      "            264 POP_JUMP_IF_FALSE      282\n",
      "\n",
      " 79         266 LOAD_GLOBAL             15 (_disassemble_recursive)\n",
      "            268 LOAD_FAST                0 (x)\n",
      "            270 LOAD_FAST                1 (file)\n",
      "            272 LOAD_FAST                2 (depth)\n",
      "            274 LOAD_CONST              10 (('file', 'depth'))\n",
      "            276 CALL_FUNCTION_KW         3\n",
      "            278 POP_TOP\n",
      "            280 JUMP_FORWARD            76 (to 358)\n",
      "\n",
      " 80     >>  282 LOAD_GLOBAL             10 (isinstance)\n",
      "            284 LOAD_FAST                0 (x)\n",
      "            286 LOAD_GLOBAL             16 (bytes)\n",
      "            288 LOAD_GLOBAL             17 (bytearray)\n",
      "            290 BUILD_TUPLE              2\n",
      "            292 CALL_FUNCTION            2\n",
      "            294 EXTENDED_ARG             1\n",
      "            296 POP_JUMP_IF_FALSE      312\n",
      "\n",
      " 81         298 LOAD_GLOBAL             18 (_disassemble_bytes)\n",
      "            300 LOAD_FAST                0 (x)\n",
      "            302 LOAD_FAST                1 (file)\n",
      "            304 LOAD_CONST               2 (('file',))\n",
      "            306 CALL_FUNCTION_KW         2\n",
      "            308 POP_TOP\n",
      "            310 JUMP_FORWARD            46 (to 358)\n",
      "\n",
      " 82     >>  312 LOAD_GLOBAL             10 (isinstance)\n",
      "            314 LOAD_FAST                0 (x)\n",
      "            316 LOAD_GLOBAL             19 (str)\n",
      "            318 CALL_FUNCTION            2\n",
      "            320 EXTENDED_ARG             1\n",
      "            322 POP_JUMP_IF_FALSE      340\n",
      "\n",
      " 83         324 LOAD_GLOBAL             20 (_disassemble_str)\n",
      "            326 LOAD_FAST                0 (x)\n",
      "            328 LOAD_FAST                1 (file)\n",
      "            330 LOAD_FAST                2 (depth)\n",
      "            332 LOAD_CONST              10 (('file', 'depth'))\n",
      "            334 CALL_FUNCTION_KW         3\n",
      "            336 POP_TOP\n",
      "            338 JUMP_FORWARD            18 (to 358)\n",
      "\n",
      " 85     >>  340 LOAD_GLOBAL             14 (TypeError)\n",
      "            342 LOAD_CONST              13 (\"don't know how to disassemble %s objects\")\n",
      "\n",
      " 86         344 LOAD_GLOBAL             21 (type)\n",
      "            346 LOAD_FAST                0 (x)\n",
      "            348 CALL_FUNCTION            1\n",
      "            350 LOAD_ATTR               22 (__name__)\n",
      "\n",
      " 85         352 BINARY_MODULO\n",
      "            354 CALL_FUNCTION            1\n",
      "            356 RAISE_VARARGS            1\n",
      "        >>  358 LOAD_CONST               1 (None)\n",
      "            360 RETURN_VALUE\n",
      "\n",
      "Disassembly of disassemble:\n",
      "367           0 LOAD_FAST                0 (co)\n",
      "              2 LOAD_ATTR                0 (co_cellvars)\n",
      "              4 LOAD_FAST                0 (co)\n",
      "              6 LOAD_ATTR                1 (co_freevars)\n",
      "              8 BINARY_ADD\n",
      "             10 STORE_FAST               3 (cell_names)\n",
      "\n",
      "368          12 LOAD_GLOBAL              2 (dict)\n",
      "             14 LOAD_GLOBAL              3 (findlinestarts)\n",
      "             16 LOAD_FAST                0 (co)\n",
      "             18 CALL_FUNCTION            1\n",
      "             20 CALL_FUNCTION            1\n",
      "             22 STORE_FAST               4 (linestarts)\n",
      "\n",
      "369          24 LOAD_GLOBAL              4 (_disassemble_bytes)\n",
      "             26 LOAD_FAST                0 (co)\n",
      "             28 LOAD_ATTR                5 (co_code)\n",
      "             30 LOAD_FAST                1 (lasti)\n",
      "             32 LOAD_FAST                0 (co)\n",
      "             34 LOAD_ATTR                6 (co_varnames)\n",
      "             36 LOAD_FAST                0 (co)\n",
      "             38 LOAD_ATTR                7 (co_names)\n",
      "\n",
      "370          40 LOAD_FAST                0 (co)\n",
      "             42 LOAD_ATTR                8 (co_consts)\n",
      "             44 LOAD_FAST                3 (cell_names)\n",
      "             46 LOAD_FAST                4 (linestarts)\n",
      "             48 LOAD_FAST                2 (file)\n",
      "\n",
      "369          50 LOAD_CONST               1 (('file',))\n",
      "             52 CALL_FUNCTION_KW         8\n",
      "             54 POP_TOP\n",
      "             56 LOAD_CONST               2 (None)\n",
      "             58 RETURN_VALUE\n",
      "\n",
      "Disassembly of disco:\n",
      "367           0 LOAD_FAST                0 (co)\n",
      "              2 LOAD_ATTR                0 (co_cellvars)\n",
      "              4 LOAD_FAST                0 (co)\n",
      "              6 LOAD_ATTR                1 (co_freevars)\n",
      "              8 BINARY_ADD\n",
      "             10 STORE_FAST               3 (cell_names)\n",
      "\n",
      "368          12 LOAD_GLOBAL              2 (dict)\n",
      "             14 LOAD_GLOBAL              3 (findlinestarts)\n",
      "             16 LOAD_FAST                0 (co)\n",
      "             18 CALL_FUNCTION            1\n",
      "             20 CALL_FUNCTION            1\n",
      "             22 STORE_FAST               4 (linestarts)\n",
      "\n",
      "369          24 LOAD_GLOBAL              4 (_disassemble_bytes)\n",
      "             26 LOAD_FAST                0 (co)\n",
      "             28 LOAD_ATTR                5 (co_code)\n",
      "             30 LOAD_FAST                1 (lasti)\n",
      "             32 LOAD_FAST                0 (co)\n",
      "             34 LOAD_ATTR                6 (co_varnames)\n",
      "             36 LOAD_FAST                0 (co)\n",
      "             38 LOAD_ATTR                7 (co_names)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "370          40 LOAD_FAST                0 (co)\n",
      "             42 LOAD_ATTR                8 (co_consts)\n",
      "             44 LOAD_FAST                3 (cell_names)\n",
      "             46 LOAD_FAST                4 (linestarts)\n",
      "             48 LOAD_FAST                2 (file)\n",
      "\n",
      "369          50 LOAD_CONST               1 (('file',))\n",
      "             52 CALL_FUNCTION_KW         8\n",
      "             54 POP_TOP\n",
      "             56 LOAD_CONST               2 (None)\n",
      "             58 RETURN_VALUE\n",
      "\n",
      "Disassembly of distb:\n",
      " 90           0 LOAD_FAST                0 (tb)\n",
      "              2 LOAD_CONST               1 (None)\n",
      "              4 IS_OP                    0\n",
      "              6 POP_JUMP_IF_FALSE       62\n",
      "\n",
      " 91           8 SETUP_FINALLY           10 (to 20)\n",
      "\n",
      " 92          10 LOAD_GLOBAL              0 (sys)\n",
      "             12 LOAD_ATTR                1 (last_traceback)\n",
      "             14 STORE_FAST               0 (tb)\n",
      "             16 POP_BLOCK\n",
      "             18 JUMP_FORWARD            28 (to 48)\n",
      "\n",
      " 93     >>   20 DUP_TOP\n",
      "             22 LOAD_GLOBAL              2 (AttributeError)\n",
      "             24 JUMP_IF_NOT_EXC_MATCH    46\n",
      "             26 POP_TOP\n",
      "             28 POP_TOP\n",
      "             30 POP_TOP\n",
      "\n",
      " 94          32 LOAD_GLOBAL              3 (RuntimeError)\n",
      "             34 LOAD_CONST               2 ('no last traceback to disassemble')\n",
      "             36 CALL_FUNCTION            1\n",
      "             38 LOAD_CONST               1 (None)\n",
      "             40 RAISE_VARARGS            2\n",
      "             42 POP_EXCEPT\n",
      "             44 JUMP_FORWARD             2 (to 48)\n",
      "        >>   46 RERAISE\n",
      "\n",
      " 95     >>   48 LOAD_FAST                0 (tb)\n",
      "             50 LOAD_ATTR                4 (tb_next)\n",
      "             52 POP_JUMP_IF_FALSE       62\n",
      "             54 LOAD_FAST                0 (tb)\n",
      "             56 LOAD_ATTR                4 (tb_next)\n",
      "             58 STORE_FAST               0 (tb)\n",
      "             60 JUMP_ABSOLUTE           48\n",
      "\n",
      " 96     >>   62 LOAD_GLOBAL              5 (disassemble)\n",
      "             64 LOAD_FAST                0 (tb)\n",
      "             66 LOAD_ATTR                6 (tb_frame)\n",
      "             68 LOAD_ATTR                7 (f_code)\n",
      "             70 LOAD_FAST                0 (tb)\n",
      "             72 LOAD_ATTR                8 (tb_lasti)\n",
      "             74 LOAD_FAST                1 (file)\n",
      "             76 LOAD_CONST               3 (('file',))\n",
      "             78 CALL_FUNCTION_KW         3\n",
      "             80 POP_TOP\n",
      "             82 LOAD_CONST               1 (None)\n",
      "             84 RETURN_VALUE\n",
      "\n",
      "Disassembly of findlabels:\n",
      "436           0 BUILD_LIST               0\n",
      "              2 STORE_FAST               1 (labels)\n",
      "\n",
      "437           4 LOAD_GLOBAL              0 (_unpack_opargs)\n",
      "              6 LOAD_FAST                0 (code)\n",
      "              8 CALL_FUNCTION            1\n",
      "             10 GET_ITER\n",
      "        >>   12 FOR_ITER                74 (to 88)\n",
      "             14 UNPACK_SEQUENCE          3\n",
      "             16 STORE_FAST               2 (offset)\n",
      "             18 STORE_FAST               3 (op)\n",
      "             20 STORE_FAST               4 (arg)\n",
      "\n",
      "438          22 LOAD_FAST                4 (arg)\n",
      "             24 LOAD_CONST               1 (None)\n",
      "             26 IS_OP                    1\n",
      "             28 POP_JUMP_IF_FALSE       12\n",
      "\n",
      "439          30 LOAD_FAST                3 (op)\n",
      "             32 LOAD_GLOBAL              1 (hasjrel)\n",
      "             34 CONTAINS_OP              0\n",
      "             36 POP_JUMP_IF_FALSE       52\n",
      "\n",
      "440          38 LOAD_FAST                2 (offset)\n",
      "             40 LOAD_CONST               2 (2)\n",
      "             42 BINARY_ADD\n",
      "             44 LOAD_FAST                4 (arg)\n",
      "             46 BINARY_ADD\n",
      "             48 STORE_FAST               5 (label)\n",
      "             50 JUMP_FORWARD            16 (to 68)\n",
      "\n",
      "441     >>   52 LOAD_FAST                3 (op)\n",
      "             54 LOAD_GLOBAL              2 (hasjabs)\n",
      "             56 CONTAINS_OP              0\n",
      "             58 POP_JUMP_IF_FALSE       12\n",
      "\n",
      "442          60 LOAD_FAST                4 (arg)\n",
      "             62 STORE_FAST               5 (label)\n",
      "             64 JUMP_FORWARD             2 (to 68)\n",
      "\n",
      "444          66 JUMP_ABSOLUTE           12\n",
      "\n",
      "445     >>   68 LOAD_FAST                5 (label)\n",
      "             70 LOAD_FAST                1 (labels)\n",
      "             72 CONTAINS_OP              1\n",
      "             74 POP_JUMP_IF_FALSE       12\n",
      "\n",
      "446          76 LOAD_FAST                1 (labels)\n",
      "             78 LOAD_METHOD              3 (append)\n",
      "             80 LOAD_FAST                5 (label)\n",
      "             82 CALL_METHOD              1\n",
      "             84 POP_TOP\n",
      "             86 JUMP_ABSOLUTE           12\n",
      "\n",
      "447     >>   88 LOAD_FAST                1 (labels)\n",
      "             90 RETURN_VALUE\n",
      "\n",
      "Disassembly of findlinestarts:\n",
      "455           0 LOAD_FAST                0 (code)\n",
      "              2 LOAD_ATTR                0 (co_lnotab)\n",
      "              4 LOAD_CONST               1 (0)\n",
      "              6 LOAD_CONST               2 (None)\n",
      "              8 LOAD_CONST               3 (2)\n",
      "             10 BUILD_SLICE              3\n",
      "             12 BINARY_SUBSCR\n",
      "             14 STORE_FAST               1 (byte_increments)\n",
      "\n",
      "456          16 LOAD_FAST                0 (code)\n",
      "             18 LOAD_ATTR                0 (co_lnotab)\n",
      "             20 LOAD_CONST               4 (1)\n",
      "             22 LOAD_CONST               2 (None)\n",
      "             24 LOAD_CONST               3 (2)\n",
      "             26 BUILD_SLICE              3\n",
      "             28 BINARY_SUBSCR\n",
      "             30 STORE_FAST               2 (line_increments)\n",
      "\n",
      "457          32 LOAD_GLOBAL              1 (len)\n",
      "             34 LOAD_FAST                0 (code)\n",
      "             36 LOAD_ATTR                2 (co_code)\n",
      "             38 CALL_FUNCTION            1\n",
      "             40 STORE_FAST               3 (bytecode_len)\n",
      "\n",
      "459          42 LOAD_CONST               2 (None)\n",
      "             44 STORE_FAST               4 (lastlineno)\n",
      "\n",
      "460          46 LOAD_FAST                0 (code)\n",
      "             48 LOAD_ATTR                3 (co_firstlineno)\n",
      "             50 STORE_FAST               5 (lineno)\n",
      "\n",
      "461          52 LOAD_CONST               1 (0)\n",
      "             54 STORE_FAST               6 (addr)\n",
      "\n",
      "462          56 LOAD_GLOBAL              4 (zip)\n",
      "             58 LOAD_FAST                1 (byte_increments)\n",
      "             60 LOAD_FAST                2 (line_increments)\n",
      "             62 CALL_FUNCTION            2\n",
      "             64 GET_ITER\n",
      "        >>   66 FOR_ITER                80 (to 148)\n",
      "             68 UNPACK_SEQUENCE          2\n",
      "             70 STORE_FAST               7 (byte_incr)\n",
      "             72 STORE_FAST               8 (line_incr)\n",
      "\n",
      "463          74 LOAD_FAST                7 (byte_incr)\n",
      "             76 POP_JUMP_IF_FALSE      122\n",
      "\n",
      "464          78 LOAD_FAST                5 (lineno)\n",
      "             80 LOAD_FAST                4 (lastlineno)\n",
      "             82 COMPARE_OP               3 (!=)\n",
      "             84 POP_JUMP_IF_FALSE      100\n",
      "\n",
      "465          86 LOAD_FAST                6 (addr)\n",
      "             88 LOAD_FAST                5 (lineno)\n",
      "             90 BUILD_TUPLE              2\n",
      "             92 YIELD_VALUE\n",
      "             94 POP_TOP\n",
      "\n",
      "466          96 LOAD_FAST                5 (lineno)\n",
      "             98 STORE_FAST               4 (lastlineno)\n",
      "\n",
      "467     >>  100 LOAD_FAST                6 (addr)\n",
      "            102 LOAD_FAST                7 (byte_incr)\n",
      "            104 INPLACE_ADD\n",
      "            106 STORE_FAST               6 (addr)\n",
      "\n",
      "468         108 LOAD_FAST                6 (addr)\n",
      "            110 LOAD_FAST                3 (bytecode_len)\n",
      "            112 COMPARE_OP               5 (>=)\n",
      "            114 POP_JUMP_IF_FALSE      122\n",
      "\n",
      "471         116 POP_TOP\n",
      "            118 LOAD_CONST               2 (None)\n",
      "            120 RETURN_VALUE\n",
      "\n",
      "472     >>  122 LOAD_FAST                8 (line_incr)\n",
      "            124 LOAD_CONST               5 (128)\n",
      "            126 COMPARE_OP               5 (>=)\n",
      "            128 POP_JUMP_IF_FALSE      138\n",
      "\n",
      "474         130 LOAD_FAST                8 (line_incr)\n",
      "            132 LOAD_CONST               6 (256)\n",
      "            134 INPLACE_SUBTRACT\n",
      "            136 STORE_FAST               8 (line_incr)\n",
      "\n",
      "475     >>  138 LOAD_FAST                5 (lineno)\n",
      "            140 LOAD_FAST                8 (line_incr)\n",
      "            142 INPLACE_ADD\n",
      "            144 STORE_FAST               5 (lineno)\n",
      "            146 JUMP_ABSOLUTE           66\n",
      "\n",
      "476     >>  148 LOAD_FAST                5 (lineno)\n",
      "            150 LOAD_FAST                4 (lastlineno)\n",
      "            152 COMPARE_OP               3 (!=)\n",
      "            154 POP_JUMP_IF_FALSE      166\n",
      "\n",
      "477         156 LOAD_FAST                6 (addr)\n",
      "            158 LOAD_FAST                5 (lineno)\n",
      "            160 BUILD_TUPLE              2\n",
      "            162 YIELD_VALUE\n",
      "            164 POP_TOP\n",
      "        >>  166 LOAD_CONST               2 (None)\n",
      "            168 RETURN_VALUE\n",
      "\n",
      "Disassembly of get_instructions:\n",
      "272           0 LOAD_GLOBAL              0 (_get_code_object)\n",
      "              2 LOAD_FAST                0 (x)\n",
      "              4 CALL_FUNCTION            1\n",
      "              6 STORE_FAST               2 (co)\n",
      "\n",
      "273           8 LOAD_FAST                2 (co)\n",
      "             10 LOAD_ATTR                1 (co_cellvars)\n",
      "             12 LOAD_FAST                2 (co)\n",
      "             14 LOAD_ATTR                2 (co_freevars)\n",
      "             16 BINARY_ADD\n",
      "             18 STORE_FAST               3 (cell_names)\n",
      "\n",
      "274          20 LOAD_GLOBAL              3 (dict)\n",
      "             22 LOAD_GLOBAL              4 (findlinestarts)\n",
      "             24 LOAD_FAST                2 (co)\n",
      "             26 CALL_FUNCTION            1\n",
      "             28 CALL_FUNCTION            1\n",
      "             30 STORE_FAST               4 (linestarts)\n",
      "\n",
      "275          32 LOAD_FAST                1 (first_line)\n",
      "             34 LOAD_CONST               1 (None)\n",
      "             36 IS_OP                    1\n",
      "             38 POP_JUMP_IF_FALSE       52\n",
      "\n",
      "276          40 LOAD_FAST                1 (first_line)\n",
      "             42 LOAD_FAST                2 (co)\n",
      "             44 LOAD_ATTR                5 (co_firstlineno)\n",
      "             46 BINARY_SUBTRACT\n",
      "             48 STORE_FAST               5 (line_offset)\n",
      "             50 JUMP_FORWARD             4 (to 56)\n",
      "\n",
      "278     >>   52 LOAD_CONST               2 (0)\n",
      "             54 STORE_FAST               5 (line_offset)\n",
      "\n",
      "279     >>   56 LOAD_GLOBAL              6 (_get_instructions_bytes)\n",
      "             58 LOAD_FAST                2 (co)\n",
      "             60 LOAD_ATTR                7 (co_code)\n",
      "             62 LOAD_FAST                2 (co)\n",
      "             64 LOAD_ATTR                8 (co_varnames)\n",
      "             66 LOAD_FAST                2 (co)\n",
      "             68 LOAD_ATTR                9 (co_names)\n",
      "\n",
      "280          70 LOAD_FAST                2 (co)\n",
      "             72 LOAD_ATTR               10 (co_consts)\n",
      "             74 LOAD_FAST                3 (cell_names)\n",
      "             76 LOAD_FAST                4 (linestarts)\n",
      "\n",
      "281          78 LOAD_FAST                5 (line_offset)\n",
      "\n",
      "279          80 CALL_FUNCTION            7\n",
      "             82 RETURN_VALUE\n",
      "\n",
      "Disassembly of pretty_flags:\n",
      "116           0 BUILD_LIST               0\n",
      "              2 STORE_FAST               1 (names)\n",
      "\n",
      "117           4 LOAD_GLOBAL              0 (range)\n",
      "              6 LOAD_CONST               1 (32)\n",
      "              8 CALL_FUNCTION            1\n",
      "             10 GET_ITER\n",
      "        >>   12 FOR_ITER                58 (to 72)\n",
      "             14 STORE_FAST               2 (i)\n",
      "\n",
      "118          16 LOAD_CONST               2 (1)\n",
      "             18 LOAD_FAST                2 (i)\n",
      "             20 BINARY_LSHIFT\n",
      "             22 STORE_FAST               3 (flag)\n",
      "\n",
      "119          24 LOAD_FAST                0 (flags)\n",
      "             26 LOAD_FAST                3 (flag)\n",
      "             28 BINARY_AND\n",
      "             30 POP_JUMP_IF_FALSE       12\n",
      "\n",
      "120          32 LOAD_FAST                1 (names)\n",
      "             34 LOAD_METHOD              1 (append)\n",
      "             36 LOAD_GLOBAL              2 (COMPILER_FLAG_NAMES)\n",
      "             38 LOAD_METHOD              3 (get)\n",
      "             40 LOAD_FAST                3 (flag)\n",
      "             42 LOAD_GLOBAL              4 (hex)\n",
      "             44 LOAD_FAST                3 (flag)\n",
      "             46 CALL_FUNCTION            1\n",
      "             48 CALL_METHOD              2\n",
      "             50 CALL_METHOD              1\n",
      "             52 POP_TOP\n",
      "\n",
      "121          54 LOAD_FAST                0 (flags)\n",
      "             56 LOAD_FAST                3 (flag)\n",
      "             58 INPLACE_XOR\n",
      "             60 STORE_FAST               0 (flags)\n",
      "\n",
      "122          62 LOAD_FAST                0 (flags)\n",
      "             64 POP_JUMP_IF_TRUE        12\n",
      "\n",
      "123          66 POP_TOP\n",
      "             68 JUMP_ABSOLUTE           86\n",
      "             70 JUMP_ABSOLUTE           12\n",
      "\n",
      "125     >>   72 LOAD_FAST                1 (names)\n",
      "             74 LOAD_METHOD              1 (append)\n",
      "             76 LOAD_GLOBAL              4 (hex)\n",
      "             78 LOAD_FAST                0 (flags)\n",
      "             80 CALL_FUNCTION            1\n",
      "             82 CALL_METHOD              1\n",
      "             84 POP_TOP\n",
      "\n",
      "126     >>   86 LOAD_CONST               3 (', ')\n",
      "             88 LOAD_METHOD              5 (join)\n",
      "             90 LOAD_FAST                1 (names)\n",
      "             92 CALL_METHOD              1\n",
      "             94 RETURN_VALUE\n",
      "\n",
      "Disassembly of show_code:\n",
      "192           0 LOAD_GLOBAL              0 (print)\n",
      "              2 LOAD_GLOBAL              1 (code_info)\n",
      "              4 LOAD_FAST                0 (co)\n",
      "              6 CALL_FUNCTION            1\n",
      "              8 LOAD_FAST                1 (file)\n",
      "             10 LOAD_CONST               1 (('file',))\n",
      "             12 CALL_FUNCTION_KW         2\n",
      "             14 POP_TOP\n",
      "             16 LOAD_CONST               2 (None)\n",
      "             18 RETURN_VALUE\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import dis, numpy\n",
    "dis.dis(numpy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feeding a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-28T13:09:14.798226Z",
     "start_time": "2023-01-28T13:09:14.794457Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  2           0 LOAD_CONST               1 (5)\n",
      "              2 STORE_FAST               0 (x)\n",
      "\n",
      "  3           4 LOAD_CONST               2 (7)\n",
      "              6 STORE_FAST               1 (y)\n",
      "\n",
      "  4           8 LOAD_FAST                0 (x)\n",
      "             10 LOAD_FAST                1 (y)\n",
      "             12 BINARY_ADD\n",
      "             14 STORE_FAST               2 (z)\n",
      "\n",
      "  5          16 LOAD_FAST                2 (z)\n",
      "             18 RETURN_VALUE\n"
     ]
    }
   ],
   "source": [
    "def bar():\n",
    "    x = 5\n",
    "    y = 7\n",
    "    z = x + y\n",
    "    return z\n",
    "\n",
    "dis.dis(bar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feeding a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-28T13:09:20.249862Z",
     "start_time": "2023-01-28T13:09:20.246038Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Disassembly of __init__:\n",
      "  3           0 LOAD_CONST               0 (None)\n",
      "              2 RETURN_VALUE\n",
      "\n",
      "Disassembly of foo:\n",
      "  6           0 LOAD_FAST                1 (x)\n",
      "              2 LOAD_CONST               1 (1)\n",
      "              4 BINARY_ADD\n",
      "              6 RETURN_VALUE\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Foo(object):\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def foo(self, x):\n",
    "        return x + 1\n",
    "\n",
    "dis.dis(Foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- https://nbviewer.org/github/rasbt/python_reference/blob/master/tutorials/not_so_obvious_python_stuff.ipynb?create=1\n",
    "- http://www.goldsborough.me/python/low-level/2016/10/04/00-31-30-disassembling_python_bytecode/\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "trainingAI",
   "language": "python",
   "name": "trainingai"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "226.667px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}