docs: def from_code(cls, co):
          """Disassemble a Python code object into a Code object"""
          free_cell_isection = set(co.co_cellvars) & set(co.co_freevars)
          if free_cell_isection:
              print(co.co_name + ': has non-empty co.co_cellvars & co.co_freevars', free_cell_isection)
              return None
  
          co_code = co.co_code
          labels = {addr: Label() for addr in findlabels(co_code)}
          linestarts = dict(cls._findlinestarts(co))
          cellfree = co.co_cellvars + co.co_freevars
          code = []
          extended_arg = 0
          is_generator = False
          is_coroutine = False
  
          for i in range(0, len(co_code), 2):
              if i in labels:
                  code.append((labels[i], None))
              if i in linestarts:
                  code.append((SetLineno, linestarts[i]))
              op = Opcode(co_code[i])
              arg = co_code[i+1] | extended_arg
              if op in hascode:
                  lastop, lastarg = code[-2]
                  if lastop != LOAD_CONST:
                      raise ValueError("%s should be preceded by LOAD_CONST" % op)
  
                  sub_code = Code.from_code(lastarg)
                  if sub_code is None:
                      print(co.co_name + ': has unexpected subcode block')
                      return None
  
                  code[-2] = (LOAD_CONST, sub_code)
              if op == opcode.EXTENDED_ARG:
                  extended_arg = arg << 8
              else:
                  if op not in hasarg:
                      code.append((op, None))
                      continue
                  extended_arg = 0
                  byteplay_arg = co.co_consts[arg] if op in hasconst else \
                                 co.co_names[arg] if op in hasname else \
                                 labels[arg] if op in hasjabs else \
                                 labels[i + 2 + arg] if op in hasjrel else \
                                 co.co_varnames[arg] if op in haslocal else \
                                 cmp_op[arg] if op in hascompare else \
                                 cellfree[arg] if op in hasfree else \
                                 arg
                  code.append((op, byteplay_arg))
  
              if op == YIELD_VALUE or op == YIELD_FROM:
                  is_generator = True
  
              if op in coroutine_opcodes:
                  is_coroutine = True
  
          varargs = not not co.co_flags & CO_VARARGS
          varkwargs = not not co.co_flags & CO_VARKEYWORDS
  
          force_coroutine = not is_coroutine and (co.co_flags & CO_COROUTINE)
          force_iterable_coroutine = co.co_flags & CO_ITERABLE_COROUTINE
          force_async_generator = co.co_flags & CO_ASYNC_GENERATOR
  
          is_generator = False if force_async_generator else is_generator
          force_generator = not is_generator and (co.co_flags & CO_GENERATOR)
  
          assert not (force_coroutine and force_iterable_coroutine)
          assert not (force_coroutine and force_async_generator)
          assert not (force_iterable_coroutine and force_async_generator)
          future_generator_stop = co.co_flags & CO_FUTURE_GENERATOR_STOP
  
          return cls(code=code,
                     freevars=co.co_freevars,
                     args=co.co_varnames[:co.co_argcount + varargs + varkwargs + co.co_kwonlyargcount],
                     kwonly=co.co_kwonlyargcount,
                     varargs=varargs,
                     varkwargs=varkwargs,
                     newlocals=not not co.co_flags & CO_NEWLOCALS,
                     name=co.co_name,
                     filename=co.co_filename,
                     firstlineno=co.co_firstlineno,
                     docstring=co.co_consts[0] if co.co_consts and isinstance(co.co_consts[0], str) else None,
                     force_generator=force_generator,
                     force_coroutine=force_coroutine,
                     force_iterable_coroutine=force_iterable_coroutine,
                     force_async_generator=force_async_generator,
                     future_generator_stop=future_generator_stop)