'Get a collection of successors out of the current job.
:param CFGJob job:  The CFGJob instance.
:return:            A collection of successors.
:rtype:             list'

def _get_successors(self, job):

    addr = job.addr
    sim_successors = job.sim_successors
    input_state = job.state
    if (self._max_steps is not None):
        depth = job.cfg_node.depth
        if (depth >= self._max_steps):
            return []
    successors = ((sim_successors.flat_successors + sim_successors.unsat_successors) if (addr not in self._avoid_runs) else [])
    (successors, job.extra_info) = self._post_process_successors(input_state, sim_successors, successors)
    all_successors = (successors + sim_successors.unconstrained_successors)
    all_successors = ([suc for suc in all_successors if (suc.history.jumpkind != 'Ijk_FakeRet')] + [suc for suc in all_successors if (suc.history.jumpkind == 'Ijk_FakeRet')])
    if self._keep_state:
        job.cfg_node.final_states = all_successors[::None]
    successors = self._resolve_indirect_jumps(sim_successors, job.cfg_node, job.func_addr, successors, job.exception_info, self._block_artifacts)
    successors = self._add_additional_edges(input_state, sim_successors, job.cfg_node, successors)
    if self._base_graph:
        basegraph_successor_addrs = set()
        for (src_, dst_) in self._base_graph.edges_iter():
            if (src_.addr == addr):
                basegraph_successor_addrs.add(dst_.addr)
        successor_addrs = set([s.se.any_int(s.ip) for s in successors])
        extra_successor_addrs = (basegraph_successor_addrs - successor_addrs)
        if all_successors:
            base_state = all_successors[0]
            for s_addr in extra_successor_addrs:
                successor_state = base_state.copy()
                successor_state.ip = s_addr
                successors.append(successor_state)
        elif extra_successor_addrs:
            l.error('CFGAccurate    terminates    at    %#x    although    base    graph    provided    more    exits.', addr)
    if (not successors):
        self._push_unresolvable_run(addr)
        if ((sim_successors.sort == 'SimProcedure') and isinstance(sim_successors.artifacts['procedure'], SIM_PROCEDURES['stubs']['PathTerminator'])):
            return_target = job.call_stack.current_return_target
            if (return_target is not None):
                new_call_stack = job.call_stack_copy()
                return_target_key = self._generate_block_id(new_call_stack.stack_suffix(self.context_sensitivity_level), return_target, False)
                if (not job.cfg_node.instruction_addrs):
                    ret_ins_addr = None
                elif self.project.arch.branch_delay_slot:
                    if (len(job.cfg_node.instruction_addrs) > 1):
                        ret_ins_addr = job.cfg_node.instruction_addrs[(-2)]
                    else:
                        l.error('At    %s:    expecting    more    than    one    instruction.    Only    got    one.', job.cfg_node)
                        ret_ins_addr = None
                else:
                    ret_ins_addr = job.cfg_node.instruction_addrs[(-1)]
                if (return_target_key in self._nodes):
                    self._graph_add_edge(job.block_id, return_target_key, jumpkind='Ijk_Ret', stmt_id='default', ins_addr=ret_ins_addr)
                else:
                    self._pending_edges[return_target_key].append((job.block_id, return_target_key, {'jumpkind': 'Ijk_Ret', 'stmt_id': 'default', 'ins_addr': ret_ins_addr}))
        else:
            pass
    if successors:
        self._handle_actions(successors[0], sim_successors, job.current_function, job.current_stack_pointer, set())
    return successors
