docs: def to_s(self):
          """
          this method is used to print the output of the executable in a readable/ tokenized format.
          sample usage:
  
          >>> from boa.compiler import Compiler
          >>> module = Compiler.load('./boa/tests/src/LambdaTest.py').default
          >>> module.write()
          >>> print(module.to_s())
          12            3   LOAD_CONST          9                [data]
                        4   STORE_FAST          j                [data]
          22            11  LOAD_FAST           j                [data]
                        17  CALL_FUNCTION       Main.<locals>.q_1 \
                                            [<boa.code.pytoken.PyToken object at 0x10cb53c50>] [data] 22
                        20  STORE_FAST          m                [data]
          24            27  243                 b'\x03\x00'      [data] 3
                        30  LOAD_FAST           m                [data]
                        35  NOP                                  [data]
                        36  241                                  [data]
                        37  242                                  [data]
                        38  RETURN_VALUE                         [data]
          20            49  243                 b'\x03\x00'      [data] 3
                        52  LOAD_FAST           x                [data]
                        57  LOAD_CONST          1                [data]
                        58  BINARY_ADD                           [data]
                        59  NOP                                  [data]
                        60  241                                  [data]
                        61  242                                  [data]
                        62  RETURN_VALUE                         [data]
          """
          # Initialize if needed
          if self.all_vm_tokens is None:
              self.link_methods()
  
          lineno = 0
          output = []
          pstart = True
  
          for i, (key, value) in enumerate(self.all_vm_tokens.items()):
              if value.pytoken:
                  pt = value.pytoken
                  do_print_line_no = False
                  to_label = None
                  from_label = '    '
  
                  if pt.lineno != lineno:
                      output.append("\n")
                      lineno = pt.lineno
                      do_print_line_no = True
  
                  ds = ''
                  if value.data is not None:
                      try:
                          ds = int.from_bytes(value.data, 'little', signed=True)
                      except Exception as e:
                          pass
                      if type(ds) is not int and len(ds) < 1:
                          try:
                              ds = value.data.decode('utf-8')
                          except Exception as e:
                              pass
  
                  lno = "{:<10}".format(
                      pt.lineno if do_print_line_no or pstart else '')
                  addr = "{:<5}".format(key)
                  op = "{:<20}".format(pt.instruction.name)
  
                  # If this is a number, it is likely a custom python opcode, get the name
                  if str(pt.pyop).isnumeric():
                      opname = pyop.to_name(int(str(pt.pyop))).replace('HAVE_ARGUMENT', 'STORE_NAME').replace('YIELD_VALUE', 'REVERSE')
                      if opname is not None:
                          op = "{:<20}".format(opname)
  
                  arg = "{:<50}".format(pt.arg_str)
                  data = "[data] {:<20}".format(ds)
                  output.append("%s%s%s%s%s%s" % (lno, from_label, addr, op, arg, data))
  
              pstart = False
  
          return "\n".join(output)