docs: def _create_jobs(self, target, jumpkind, current_function_addr, soot_block, addr, cfg_node, stmt_addr, stmt_idx):  # pylint:disable=arguments-differ
  
          """
          Given a node and details of a successor, makes a list of CFGJobs
          and if it is a call or exit marks it appropriately so in the CFG
  
          :param int target:          Destination of the resultant job
          :param str jumpkind:        The jumpkind of the edge going to this node
          :param int current_function_addr: Address of the current function
          :param pyvex.IRSB irsb:     IRSB of the predecessor node
          :param int addr:            The predecessor address
          :param CFGNode cfg_node:    The CFGNode of the predecessor node
          :param int ins_addr:        Address of the source instruction.
          :param int stmt_addr:       ID of the source statement.
          :return:                    a list of CFGJobs
          :rtype:                     list
          """
  
          target_addr = target
  
          jobs = [ ]
  
          if target_addr is None:
              # The target address is not a concrete value
  
              if jumpkind == "Ijk_Ret":
                  # This block ends with a return instruction.
                  if current_function_addr != -1:
                      self._function_exits[current_function_addr].add(addr)
                      self._function_add_return_site(addr, current_function_addr)
                      self.functions[current_function_addr].returning = True
                      self._pending_jobs.add_returning_function(current_function_addr)
  
                  cfg_node.has_return = True
  
          elif target_addr is not None:
              # This is a direct jump with a concrete target.
  
              # pylint: disable=too-many-nested-blocks
              if jumpkind in ('Ijk_Boring', 'Ijk_InvalICache'):
                  # it might be a jumpout
                  target_func_addr = None
                  if target_addr in self._traced_addresses:
                      node = self.get_any_node(target_addr)
                      if node is not None:
                          target_func_addr = node.function_address
                  if target_func_addr is None:
                      target_func_addr = current_function_addr
  
                  to_outside = not target_func_addr == current_function_addr
  
                  edge = FunctionTransitionEdge(cfg_node, target_addr, current_function_addr,
                                                to_outside=to_outside,
                                                dst_func_addr=target_func_addr,
                                                ins_addr=stmt_addr,
                                                stmt_idx=stmt_idx,
                                                )
  
                  ce = CFGJob(target_addr, target_func_addr, jumpkind, last_addr=addr, src_node=cfg_node,
                              src_ins_addr=stmt_addr, src_stmt_idx=stmt_idx, func_edges=[ edge ])
                  jobs.append(ce)
  
              elif jumpkind == 'Ijk_Call' or jumpkind.startswith("Ijk_Sys"):
                  jobs += self._create_job_call(addr, soot_block, cfg_node, stmt_idx, stmt_addr, current_function_addr,
                                                target_addr, jumpkind, is_syscall=False
                                                )
                  self._pending_jobs.add_returning_function(target.method)
  
              else:
                  # TODO: Support more jumpkinds
                  l.debug("Unsupported jumpkind %s", jumpkind)
  
          return jobs