docs: def from_pycode(cls, co):
          """Create a Code object from a python code object.
  
          Parameters
          ----------
          co : CodeType
              The python code object.
  
          Returns
          -------
          code : Code
              The codetransformer Code object.
          """
          # Make it sparse to instrs[n] is the instruction at bytecode[n]
          sparse_instrs = tuple(
              _sparse_args(
                  Instruction.from_opcode(
                      b.opcode,
                      Instruction._no_arg if b.arg is None else _RawArg(b.arg),
                  ) for b in Bytecode(co)
              ),
          )
          for idx, instr in enumerate(sparse_instrs):
              if instr is None:
                  # The sparse value
                  continue
              if instr.absjmp:
                  instr.arg = sparse_instrs[instr.arg]
              elif instr.reljmp:
                  instr.arg = sparse_instrs[instr.arg + idx + argsize + 1]
              elif isinstance(instr, LOAD_CONST):
                  instr.arg = co.co_consts[instr.arg]
              elif instr.uses_name:
                  instr.arg = co.co_names[instr.arg]
              elif instr.uses_varname:
                  instr.arg = co.co_varnames[instr.arg]
              elif instr.uses_free:
                  instr.arg = _freevar_argname(
                      instr.arg,
                      co.co_freevars,
                      co.co_cellvars,
                  )
              elif instr.have_arg and isinstance(instr.arg, _RawArg):
                  instr.arg = int(instr.arg)
  
          flags = Flag.unpack(co.co_flags)
          has_vargs = flags['CO_VARARGS']
          has_kwargs = flags['CO_VARKEYWORDS']
  
          # Here we convert the varnames format into our argnames format.
          paramnames = co.co_varnames[
              :(co.co_argcount +
                co.co_kwonlyargcount +
                has_vargs +
                has_kwargs)
          ]
          # We start with the positional arguments.
          new_paramnames = list(paramnames[:co.co_argcount])
          # Add *args next.
          if has_vargs:
              new_paramnames.append('*' + paramnames[-1 - has_kwargs])
          # Add positional only arguments next.
          new_paramnames.extend(paramnames[
              co.co_argcount:co.co_argcount + co.co_kwonlyargcount
          ])
          # Add **kwargs last.
          if has_kwargs:
              new_paramnames.append('**' + paramnames[-1])
  
          return cls(
              filter(bool, sparse_instrs),
              argnames=new_paramnames,
              cellvars=co.co_cellvars,
              freevars=co.co_freevars,
              name=co.co_name,
              filename=co.co_filename,
              firstlineno=co.co_firstlineno,
              lnotab={
                  lno: sparse_instrs[off] for off, lno in findlinestarts(co)
              },
              flags=flags,
          )