'Symbolically executes from ancestor nodes (2-5 times removed) finding paths of execution through the given
CFGNode.
:param SimSuccessors current_block: SimSuccessor with address to attempt to navigate to.
:param dict block_artifacts:  Container of IRSB data - specifically used for known persistant register values.
:param CFGNode cfg_node:      Current node interested around.
:returns:                     Double checked concrete successors.
:rtype: List'

def _symbolically_back_traverse(self, current_block, block_artifacts, cfg_node):

    class register_protector(object, ):
        def __init__(self, reg_offset, info_collection):
            '\n                                                                Class    to    overwrite    registers.\n\n                                                                :param    int    reg_offest:                            Register    offset    to    overwrite    from.\n                                                                :param    dict    info_collection:    New    register    offsets    to    use    (in    container).\n                                                                '
            self._reg_offset = reg_offset
            self._info_collection = info_collection
        def write_persistent_register(self, state_):
            '\n                                                                Writes    over    given    registers    from    self._info_coollection    (taken    from    block_artifacts)\n\n                                                                :param    SimSuccessors    state_:    state    to    update    registers    for\n                                                                '
            if (state_.inspect.address is None):
                l.error('state.inspect.address    is    None.    It    will    be    fixed    by    Yan    later.')
                return
            if state_.registers.load(self._reg_offset).symbolic:
                current_run = state_.inspect.address
                if ((current_run in self._info_collection) and (not state_.se.symbolic(self._info_collection[current_run][self._reg_offset]))):
                    l.debug('Overwriting    %s    with    %s', state_.registers.load(self._reg_offset), self._info_collection[current_run][self._reg_offset])
                    state_.registers.store(self._reg_offset, self._info_collection[current_run][self._reg_offset])
    l.debug('Start    back    traversal    from    %s', current_block)
    temp_cfg = networkx.DiGraph(self.graph)
    temp_cfg.reverse(copy=False)
    path_length = 0
    concrete_exits = []
    if (cfg_node not in temp_cfg.nodes()):
        return concrete_exits
    keep_running = True
    while ((not concrete_exits) and (path_length < 5) and keep_running):
        path_length += 1
        queue = [cfg_node]
        avoid = set()
        for _ in xrange(path_length):
            new_queue = []
            for n in queue:
                successors = temp_cfg.successors(n)
                for suc in successors:
                    jk = temp_cfg.get_edge_data(n, suc)['jumpkind']
                    if (jk != 'Ijk_Ret'):
                        predecessors = temp_cfg.predecessors(suc)
                        avoid |= set([p.addr for p in predecessors if (p is not n)])
                        new_queue.append(suc)
            queue = new_queue
        if (path_length <= 1):
            continue
        for n in queue:
            state = self.project.factory.blank_state(addr=n.addr, mode='symbolic', add_options=({o.DO_RET_EMULATION, o.CONSERVATIVE_READ_STRATEGY} | o.resilience_options))
            if (n.addr in block_artifacts):
                for reg in state.arch.persistent_regs:
                    state.registers.store(reg, block_artifacts[n.addr][reg])
            for reg in state.arch.persistent_regs:
                reg_protector = register_protector(reg, block_artifacts)
                state.inspect.add_breakpoint('reg_write', BP(BP_AFTER, reg_write_offset=state.arch.registers[reg][0], action=reg_protector.write_persistent_register))
            result = self.project.surveyors.Explorer(start=self.project.factory.path(state), find=(current_block.addr,), avoid=avoid, max_repeats=10, max_depth=path_length).run()
            if result.found:
                if ((not result.found[0].errored) and result.found[0].step()):
                    keep_running = False
                    concrete_exits.extend([s for s in result.found[0].next_run.flat_successors])
                    concrete_exits.extend([s for s in result.found[0].next_run.unsat_successors])
            if keep_running:
                l.debug('Step    back    for    one    more    run...')
    new_concrete_successors = []
    for c in concrete_exits:
        unsat_state = current_block.unsat_successors[0].copy()
        unsat_state.history.jumpkind = c.history.jumpkind
        for reg in (unsat_state.arch.persistent_regs + ['ip']):
            unsat_state.registers.store(reg, c.registers.load(reg))
        new_concrete_successors.append(unsat_state)
    return new_concrete_successors
