'Execute each basic block with an indeterminiable exit target
:returns:'

def _process_indirect_jumps(self):

    function_starts = set()
    print ('We    have    %d    indirect    jumps' % len(self._indirect_jumps))
    for (jumpkind, irsb_addr) in self._indirect_jumps:
        if (len(function_starts) > 20):
            break
        if (jumpkind == 'Ijk_Call'):
            state = self.project.factory.blank_state(addr=irsb_addr, mode='concrete', add_options={o.SYMBOLIC_INITIAL_VALUES})
            path = self.project.factory.path(state)
            print hex(irsb_addr)
            try:
                r = (path.next_run.successors + path.next_run.unsat_successors)[0]
                ip = r.se.exactly_n_int(r.ip, 1)[0]
                function_starts.add(ip)
                continue
            except SimSolverModeError as ex:
                pass
            irsb = self.project.factory.block(irsb_addr).vex
            stmts = irsb.statements
            b = Blade(self.cfg, irsb.addr, (-1), project=self.project)
            for (addr, stmt_idx) in sorted(list(b.slice.nodes())):
                irsb = self.project.factory.block(addr).vex
                stmts = irsb.statements
                print ('%x:    %d    |    ' % (addr, stmt_idx)),
                print ('%s' % stmts[stmt_idx]),
                print ('%d' % b.slice.in_degree((addr, stmt_idx)))
            print ''
            sources = [n for n in b.slice.nodes() if (b.slice.in_degree(n) == 0)]
            annotatedcfg = AnnotatedCFG(self.project, None, target_irsb_addr=irsb_addr, detect_loops=False)
            annotatedcfg.from_digraph(b.slice)
            for (src_irsb, src_stmt_idx) in sources:
                start_state = self.project.factory.blank_state(addr=src_irsb, add_options={o.DO_RET_EMULATION, o.TRUE_RET_EMULATION_GUARD})
                start_path = self.project.factory.path(start_state)
                slicecutor = Slicecutor(self.project, annotatedcfg, start=start_path, targets=(irsb_addr,))
                try:
                    slicecutor.run()
                except KeyError as ex:
                    l.debug('KeyError    occurred    due    to    incomplete    program    slice.', exc_info=ex)
                    continue
                for r in slicecutor.reached_targets:
                    if r.next_run.successors:
                        target_ip = r.next_run.successors[0].ip
                        se = r.next_run.successors[0].se
                        if (not se.symbolic(target_ip)):
                            concrete_ip = se.exactly_n_int(target_ip, 1)[0]
                            function_starts.add(concrete_ip)
                            l.info('Found    a    function    address    %x', concrete_ip)
    return function_starts
