'The call will be skipped if it returns True.
:param call_target_state:   The new state of the call target.
:param jumpkind:            The Jumpkind of this call.
:returns:                   True if we want to skip this call, False otherwise.'

def filter(self, call_target_state, jumpkind):

    ACCEPT = False
    REJECT = True
    l.debug('Filtering    calling    target    %s', call_target_state.ip)
    ip = call_target_state.ip
    if (self.depth >= 5):
        l.debug('Rejecting    target    %s    -    too    deep,    depth    is    %d', ip, self.depth)
        return REJECT
    try:
        addr = call_target_state.se.exactly_int(ip)
    except (SimValueError, SimSolverModeError):
        self._skipped_targets.add((-1))
        l.debug('Rejecting    target    %s    -    cannot    be    concretized', ip)
        return REJECT
    if (addr in self.blacklist):
        self._skipped_targets.add(addr)
        l.debug('Rejecting    target    0x%x    -    blacklisted', addr)
        return REJECT
    if (self.project.is_hooked(addr) and (type(self.project._sim_procedures[addr][0]) in CallTracingFilter.whitelist)):
        l.debug('Accepting    target    0x%x,    jumpkind    %s', addr, jumpkind)
        return ACCEPT
    if jumpkind.startswith('Ijk_Sys'):
        call_target_state.history.jumpkind = jumpkind
        successors_ = self.project.factory.successors(call_target_state)
        try:
            next_run = successors_.artifacts['procedure']
        except KeyError:
            l.warning("CallTracingFilter.filter():    except    artifacts['procedure']    in    %s.    Reject.", successors_)
            return REJECT
        if (type(next_run) in CallTracingFilter.whitelist):
            l.debug('Accepting    target    0x%x,    jumpkind    %s', addr, jumpkind)
            return ACCEPT
        else:
            l.debug('Rejecting    target    0x%x    -    syscall    %s    not    in    whitelist', addr, type(next_run))
            return REJECT
    cfg_key = (addr, jumpkind)
    if (cfg_key not in self.cfg_cache):
        new_blacklist = self.blacklist[::None]
        new_blacklist.append(addr)
        tracing_filter = CallTracingFilter(self.project, depth=(self.depth + 1), blacklist=new_blacklist)
        cfg = self.project.analyses.CFGAccurate(starts=((addr, jumpkind),), initial_state=call_target_state, context_sensitivity_level=0, call_depth=1, call_tracing_filter=tracing_filter.filter, normalize=True, kb=KnowledgeBase(self.project, self.project.loader.main_object))
        self.cfg_cache[cfg_key] = (cfg, tracing_filter)
        try:
            cfg.force_unroll_loops(1)
        except AngrCFGError:
            l.debug('Rejecting    target    %#x    -    loop    unrolling    failed', addr)
            return REJECT
    else:
        l.debug('Loading    CFG    from    CFG    cache')
        (cfg, tracing_filter) = self.cfg_cache[cfg_key]
    if cfg._loop_back_edges:
        self._skipped_targets.add(addr)
        l.debug('Rejecting    target    0x%x    -    it    has    loops', addr)
        return REJECT
    sim_procedures = [n for n in cfg.graph.nodes() if (n.simprocedure_name is not None)]
    for sp_node in sim_procedures:
        if (not self.project.is_hooked(sp_node.addr)):
            continue
        if (self.project._sim_procedures[sp_node.addr].procedure not in CallTracingFilter.whitelist):
            self._skipped_targets.add(addr)
            l.debug('Rejecting    target    0x%x    -    contains    SimProcedures    outside    whitelist', addr)
            return REJECT
    if len(tracing_filter._skipped_targets):
        self._skipped_targets.add(addr)
        l.debug('Rejecting    target    0x%x    -    should    be    skipped', addr)
        return REJECT
    l.debug('Accepting    target    0x%x,    jumpkind    %s', addr, jumpkind)
    return ACCEPT
