def _pre_entry_handling(self, entry, _locals):
        """
        Before processing an entry.
        Right now each SimRun is traced at most once. If it is traced more than once, we will mark it as "should_skip"
        before tracing it.
        An AngrForwardAnalysisSkipEntry exception is raised in order to skip analyzing the entry.

        :param EntryWrapper entry: The entry object
        :param dict _locals: A bunch of local variables that will be kept around when handling this entry and its
                        corresponding successors.
        :return: None
        """

        # Extract initial info from entry_wrapper
        path = _locals['path'] = entry.path
        call_stack_suffix = _locals['call_stack_suffix'] = entry.call_stack_suffix()
        addr = _locals['addr'] = entry.path.addr
        func_addr = _locals['func_addr'] = entry.current_function_address
        _locals['current_stack_pointer'] = entry.current_stack_pointer
        _locals['accessed_registers_in_function'] = entry.current_function_accessed_registers
        _locals['current_function'] = self.kb.functions.function(_locals['func_addr'], create=True)
        jumpkind = _locals['jumpkind'] = 'Ijk_Boring' if entry.path.state.scratch.jumpkind is None else \
            entry.path.state.scratch.jumpkind
        src_simrun_key = entry.src_simrun_key
        src_exit_stmt_idx = entry.src_exit_stmt_idx

        # Log this address
        if l.level == logging.DEBUG:
            self._analyzed_addrs.add(addr)

        if addr == func_addr:
            # Store the input state of this function
            self._function_input_states[func_addr] = path.state

        # Generate a unique key for this SimRun
        simrun_key = self._generate_simrun_key(call_stack_suffix, addr, jumpkind.startswith('Ijk_Sys'))

        # Should we skip tracing this SimRun?
        should_skip = False
        if self._traced_addrs[call_stack_suffix][addr] > 1:
            should_skip = True
        elif (jumpkind == 'Ijk_Call' or jumpkind.startswith('Ijk_Sys')) and \
                (self._call_depth is not None and
                         self._call_depth > len(entry.call_stack) and
                     (
                            self._call_tracing_filter is None or
                            self._call_tracing_filter(path.state, jumpkind)
                     )
                 ):
            should_skip = True

        # Get a SimRun out of current SimExit
        simrun, error_occurred, _ = self._get_simrun(addr, path, current_function_addr=func_addr)
        if simrun is None or should_skip:
            # We cannot retrieve the SimRun, or we should skip the analysis of this node

            # But we create the edge anyway. If the simrun does not exist, it will be an edge from the previous node to
            # a PathTerminator
            self._graph_add_edge(src_simrun_key, simrun_key, jumpkind=jumpkind, exit_stmt_idx=src_exit_stmt_idx)
            self._update_function_transition_graph(src_simrun_key, simrun_key, jumpkind=jumpkind)

            # If this entry cancels another FakeRet entry, we should also create the FekeRet edge
            if entry.cancelled_pending_entry is not None:
                pending_entry = entry.cancelled_pending_entry
                self._graph_add_edge(pending_entry.src_simrun_key, simrun_key, jumpkind='Ijk_FakeRet',
                                     exit_stmt_idx=pending_entry.src_exit_stmt_idx
                                     )
                self._update_function_transition_graph(pending_entry.src_simrun_key, simrun_key, jumpkind='Ijk_FakeRet')

            # We are good. Raise the exception and leave
            raise AngrForwardAnalysisSkipEntry()

        self._update_thumb_addrs(simrun, path.state)

        # We store the function hints first. Function hints will be checked at the end of the analysis to avoid
        # any duplication with existing jumping targets
        if self._enable_function_hints:
            function_hints = self._search_for_function_hints(simrun)
            for f in function_hints:
                self._pending_function_hints.add(f)

        # Increment tracing count for this SimRun
        self._traced_addrs[call_stack_suffix][addr] += 1

        # Create the CFGNode object
        cfg_node = self._create_cfgnode(simrun, call_stack_suffix, func_addr)

        if self._keep_state:
            cfg_node.input_state = simrun.initial_state

        self._nodes[simrun_key] = cfg_node
        self._nodes_by_addr[cfg_node.addr].append((simrun_key, cfg_node))

        self._graph_add_edge(src_simrun_key, simrun_key, jumpkind=jumpkind, exit_stmt_idx=src_exit_stmt_idx)
        self._update_function_transition_graph(src_simrun_key, simrun_key, jumpkind=jumpkind)

        # See if this entry cancels another FakeRet
        if entry.cancelled_pending_entry is not None:
            pending_entry = entry.cancelled_pending_entry
            self._graph_add_edge(pending_entry.src_simrun_key, simrun_key, jumpkind='Ijk_FakeRet',
                                 exit_stmt_idx=pending_entry.src_exit_stmt_idx
                                 )
            self._update_function_transition_graph(pending_entry.src_simrun_key, simrun_key, jumpkind='Ijk_FakeRet')

        simrun_info = self.project.arch.gather_info_from_state(simrun.initial_state)
        self._simrun_info_collection[addr] = simrun_info

        _locals['simrun'] = simrun
        _locals['simrun_key'] = simrun_key
        _locals['cfg_node'] = cfg_node
        _locals['error_occurred'] = error_occurred

        # For debugging purposes!
        _locals['successor_status'] = {}
dataset/ETHPy150Open angr/angr/angr/analyses/cfg_accurate.py/CFGAccurate._pre_entry_handling/swapped operands of `>`