angr 9.2.101__py3-none-manylinux2014_x86_64.whl → 9.2.103__py3-none-manylinux2014_x86_64.whl

angr/engines/pcode/lifter.py

@@ -6,7 +6,8 @@
 #     - Fix/remove NotImplementedError's
 
 import logging
-from typing import Union, Optional, Iterable, Sequence, Tuple
+from typing import Optional
+from collections.abc import Iterable, Sequence
 
 import archinfo
 from archinfo import ArchARM, ArchPcode
@@ -49,10 +50,10 @@ class ExitStatement:
 
     __slots__ = ("dst", "jumpkind")
 
-    dst: Optional[int]
+    dst: int | None
     jumpkind: str
 
-    def __init__(self, dst: Optional[int], jumpkind: str):
+    def __init__(self, dst: int | None, jumpkind: str):
         self.dst = dst
         self.jumpkind = jumpkind
 
@@ -125,20 +126,20 @@ class IRSB:
         "next",
     )
 
-    _direct_next: Optional[bool]
-    _exit_statements: Sequence[Tuple[int, int, ExitStatement]]
-    _instruction_addresses: Optional[Sequence[int]]
+    _direct_next: bool | None
+    _exit_statements: Sequence[tuple[int, int, ExitStatement]]
+    _instruction_addresses: Sequence[int] | None
     _ops: Sequence["pypcode.PcodeOp"]  # FIXME: Merge into _statements
-    _size: Optional[int]
+    _size: int | None
     _statements: Iterable  # Note: currently unused
-    _disassembly: Optional[PcodeDisassemblerBlock]
+    _disassembly: PcodeDisassemblerBlock | None
     addr: int
     arch: archinfo.Arch
-    behaviors: Optional[BehaviorFactory]
+    behaviors: BehaviorFactory | None
     data_refs: Sequence  # Note: currently unused
     default_exit_target: Optional  # Note: currently used
-    jumpkind: Optional[str]
-    next: Optional[int]
+    jumpkind: str | None
+    next: int | None
 
     # The following constants shall match the defs in pyvex.h
     MAX_EXITS = 400
@@ -146,16 +147,16 @@ class IRSB:
 
     def __init__(
         self,
-        data: Union[str, bytes, None],
+        data: str | bytes | None,
         mem_addr: int,
         arch: archinfo.Arch,
-        max_inst: Optional[int] = None,
-        max_bytes: Optional[int] = None,
+        max_inst: int | None = None,
+        max_bytes: int | None = None,
         bytes_offset: int = 0,
         traceflags: int = 0,
         opt_level: int = 1,
-        num_inst: Optional[int] = None,
-        num_bytes: Optional[int] = None,
+        num_inst: int | None = None,
+        num_bytes: int | None = None,
         strict_block_end: bool = False,
         skip_stmts: bool = False,
         collect_data_refs: bool = False,
@@ -230,12 +231,12 @@ class IRSB:
     def empty_block(
         arch: archinfo.Arch,
         addr: int,
-        statements: Optional[Sequence] = None,
-        nxt: Optional[int] = None,
+        statements: Sequence | None = None,
+        nxt: int | None = None,
         tyenv=None,  # Unused, kept for compatibility
-        jumpkind: Optional[str] = None,
-        direct_next: Optional[bool] = None,
-        size: Optional[int] = None,
+        jumpkind: str | None = None,
+        direct_next: bool | None = None,
+        size: int | None = None,
     ) -> "IRSB":
         block = IRSB(None, addr, arch)
         block._set_attributes(statements, nxt, tyenv, jumpkind, direct_next, size=size)
@@ -246,7 +247,7 @@ class IRSB:
         return self.statements is not None and self.statements
 
     @property
-    def exit_statements(self) -> Sequence[Tuple[int, int, ExitStatement]]:
+    def exit_statements(self) -> Sequence[tuple[int, int, ExitStatement]]:
         return self._exit_statements
 
     def copy(self) -> "IRSB":
@@ -457,14 +458,14 @@ class IRSB:
     def _set_attributes(
         self: "IRSB",
         statements: Iterable = None,
-        nxt: Optional[int] = None,
+        nxt: int | None = None,
         tyenv=None,  # Unused, kept for compatibility
-        jumpkind: Optional[str] = None,
-        direct_next: Optional[bool] = None,
-        size: Optional[int] = None,
-        ops: Optional[Sequence["pypcode.PcodeOp"]] = None,
-        instruction_addresses: Optional[Iterable[int]] = None,
-        exit_statements: Sequence[Tuple[int, int, ExitStatement]] = None,
+        jumpkind: str | None = None,
+        direct_next: bool | None = None,
+        size: int | None = None,
+        ops: Sequence["pypcode.PcodeOp"] | None = None,
+        instruction_addresses: Iterable[int] | None = None,
+        exit_statements: Sequence[tuple[int, int, ExitStatement]] = None,
         default_exit_target: Optional = None,
     ) -> None:
         # pylint: disable=unused-argument
@@ -539,15 +540,15 @@ class Lifter:
         "addr",
     )
 
-    data: Union[str, bytes, None]
-    bytes_offset: Optional[int]
+    data: str | bytes | None
+    bytes_offset: int | None
     opt_level: int
-    traceflags: Optional[int]
-    allow_arch_optimizations: Optional[bool]
-    strict_block_end: Optional[bool]
+    traceflags: int | None
+    allow_arch_optimizations: bool | None
+    strict_block_end: bool | None
     collect_data_refs: bool
-    max_inst: Optional[int]
-    max_bytes: Optional[int]
+    max_inst: int | None
+    max_bytes: int | None
     skip_stmts: bool
     irsb: IRSB
     arch: archinfo.Arch
@@ -570,14 +571,14 @@ class Lifter:
 
     def _lift(
         self,
-        data: Union[str, bytes, None],
-        bytes_offset: Optional[int] = None,
-        max_bytes: Optional[int] = None,
-        max_inst: Optional[int] = None,
+        data: str | bytes | None,
+        bytes_offset: int | None = None,
+        max_bytes: int | None = None,
+        max_inst: int | None = None,
         opt_level: int = 1,
-        traceflags: Optional[int] = None,
-        allow_arch_optimizations: Optional[bool] = None,
-        strict_block_end: Optional[bool] = None,
+        traceflags: int | None = None,
+        allow_arch_optimizations: bool | None = None,
+        strict_block_end: bool | None = None,
         skip_stmts: bool = False,
         collect_data_refs: bool = False,
     ) -> IRSB:
@@ -627,11 +628,11 @@ class Lifter:
 
 # pylint:disable=unused-argument
 def lift(
-    data: Union[str, bytes, None],
+    data: str | bytes | None,
     addr: int,
     arch: archinfo.Arch,
-    max_bytes: Optional[int] = None,
-    max_inst: Optional[int] = None,
+    max_bytes: int | None = None,
+    max_inst: int | None = None,
     bytes_offset: int = 0,
     opt_level: int = 1,
     traceflags: int = 0,
@@ -837,10 +838,10 @@ class PcodeBasicBlockLifter:
         self,
         irsb: IRSB,
         baseaddr: int,
-        data: Union[bytes, bytearray],
+        data: bytes | bytearray,
         bytes_offset: int = 0,
-        max_bytes: Optional[int] = None,
-        max_inst: Optional[int] = None,
+        max_bytes: int | None = None,
+        max_inst: int | None = None,
         branch_delay_slot: bool = False,
         is_sparc32: bool = False,
     ) -> None:
@@ -994,10 +995,10 @@ class PcodeLifterEngineMixin(SimEngineBase):
     def __init__(
         self,
         project=None,
-        use_cache: Optional[bool] = None,
+        use_cache: bool | None = None,
         cache_size: int = 50000,
         default_opt_level: int = 1,
-        selfmodifying_code: Optional[bool] = None,
+        selfmodifying_code: bool | None = None,
         single_step: bool = False,
         default_strict_block_end: bool = False,
         **kwargs,
@@ -1041,22 +1042,22 @@ class PcodeLifterEngineMixin(SimEngineBase):
     # FIXME: Consider moving to higher abstraction layer to reduce duplication with vex
     def lift_vex(
         self,
-        addr: Optional[int] = None,
-        state: Optional[SimState] = None,
-        clemory: Optional[cle.Clemory] = None,
-        insn_bytes: Optional[bytes] = None,
-        arch: Optional[archinfo.Arch] = None,
-        size: Optional[int] = None,
-        num_inst: Optional[int] = None,
+        addr: int | None = None,
+        state: SimState | None = None,
+        clemory: cle.Clemory | None = None,
+        insn_bytes: bytes | None = None,
+        arch: archinfo.Arch | None = None,
+        size: int | None = None,
+        num_inst: int | None = None,
         traceflags: int = 0,
         thumb: bool = False,
-        extra_stop_points: Optional[Iterable[int]] = None,
-        opt_level: Optional[int] = None,
-        strict_block_end: Optional[bool] = None,
+        extra_stop_points: Iterable[int] | None = None,
+        opt_level: int | None = None,
+        strict_block_end: bool | None = None,
         skip_stmts: bool = False,
         collect_data_refs: bool = False,
         load_from_ro_regions: bool = False,
-        cross_insn_opt: Optional[bool] = None,
+        cross_insn_opt: bool | None = None,
     ):
         """
         Temporary compatibility interface for integration with block code.
@@ -1082,22 +1083,22 @@ class PcodeLifterEngineMixin(SimEngineBase):
 
     def lift_pcode(
         self,
-        addr: Optional[int] = None,
-        state: Optional[SimState] = None,
-        clemory: Optional[cle.Clemory] = None,
-        insn_bytes: Optional[bytes] = None,
-        arch: Optional[archinfo.Arch] = None,
-        size: Optional[int] = None,
-        num_inst: Optional[int] = None,
+        addr: int | None = None,
+        state: SimState | None = None,
+        clemory: cle.Clemory | None = None,
+        insn_bytes: bytes | None = None,
+        arch: archinfo.Arch | None = None,
+        size: int | None = None,
+        num_inst: int | None = None,
         traceflags: int = 0,
         thumb: bool = False,
-        extra_stop_points: Optional[Iterable[int]] = None,
-        opt_level: Optional[int] = None,
-        strict_block_end: Optional[bool] = None,
+        extra_stop_points: Iterable[int] | None = None,
+        opt_level: int | None = None,
+        strict_block_end: bool | None = None,
         skip_stmts: bool = False,
         collect_data_refs: bool = False,
         load_from_ro_regions: bool = False,
-        cross_insn_opt: Optional[bool] = None,
+        cross_insn_opt: bool | None = None,
     ):
         """
         Lift an IRSB.
@@ -1296,8 +1297,8 @@ class PcodeLifterEngineMixin(SimEngineBase):
             raise SimTranslationError("Unable to translate bytecode") from e
 
     def _load_bytes(
-        self, addr: int, max_size: int, state: Optional[SimState] = None, clemory: Optional[cle.Clemory] = None
-    ) -> Tuple[bytes, int, int]:
+        self, addr: int, max_size: int, state: SimState | None = None, clemory: cle.Clemory | None = None
+    ) -> tuple[bytes, int, int]:
         if clemory is None and state is None:
             raise SimEngineError("state and clemory cannot both be None in _load_bytes().")
 
@@ -1371,7 +1372,7 @@ class PcodeLifterEngineMixin(SimEngineBase):
         size = min(max_size, size)
         return buff, size, offset
 
-    def _first_stoppoint(self, irsb: IRSB, extra_stop_points: Optional[Sequence[int]] = None) -> Optional[int]:
+    def _first_stoppoint(self, irsb: IRSB, extra_stop_points: Sequence[int] | None = None) -> int | None:
         """
         Enumerate the imarks in the block. If any of them (after the first one) are at a stop point, returns the address
         of the stop point. None is returned otherwise.
@@ -1388,7 +1389,7 @@ class PcodeLifterEngineMixin(SimEngineBase):
             first_imark = False
         return None
 
-    def __is_stop_point(self, addr: int, extra_stop_points: Optional[Sequence[int]] = None) -> bool:
+    def __is_stop_point(self, addr: int, extra_stop_points: Sequence[int] | None = None) -> bool:
         if self.project is not None and addr in self.project._sim_procedures:
             return True
         elif extra_stop_points is not None and addr in extra_stop_points:

angr/engines/vex/claripy/ccall.py

@@ -1,4 +1,3 @@
-from typing import Dict, Optional
 import logging
 
 import claripy
@@ -74,7 +73,7 @@ class CCallMultivaluedException(Exception):
 ### x86* data ###
 ##################
 
-data: Dict[str, Dict[str, Dict[str, Optional[int]]]] = {
+data: dict[str, dict[str, dict[str, int | None]]] = {
     "AMD64": {
         "CondTypes": {},
         "CondBitOffsets": {},

angr/engines/vex/claripy/datalayer.py

@@ -1,4 +1,3 @@
-from typing import Optional
 import logging
 
 import claripy
@@ -14,7 +13,7 @@ l = logging.getLogger(__name__)
 zero = claripy.BVV(0, 32)
 
 
-def value(ty, val, size: Optional[int] = None):
+def value(ty, val, size: int | None = None):
     if ty == "Ity_F32":
         return claripy.FPV(float(val), claripy.FSORT_FLOAT)
     elif ty == "Ity_F64":

angr/engines/vex/light/light.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 import pyvex
 
@@ -549,7 +548,7 @@ class VEXMixin(SimEngineBase):
         self.stmt_idx = DEFAULT_STATEMENT
         self._handle_vex_defaultexit(irsb.next, irsb.jumpkind)
 
-    def _handle_vex_defaultexit(self, expr: Optional[pyvex.expr.IRExpr], jumpkind: str):
+    def _handle_vex_defaultexit(self, expr: pyvex.expr.IRExpr | None, jumpkind: str):
         self._perform_vex_defaultexit(self._analyze_vex_defaultexit(expr) if expr is not None else None, jumpkind)
 
     def _perform_vex_defaultexit(self, expr, jumpkind):

angr/exploration_techniques/tracer.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, TYPE_CHECKING
+from typing import TYPE_CHECKING
 import logging
 import cle
 
@@ -179,13 +179,13 @@ class Tracer(ExplorationTechnique):
         self._follow_unsat = follow_unsat
         self._fast_forward_to_entry = fast_forward_to_entry
 
-        self._aslr_slides: Dict[cle.Backend, int] = {}
+        self._aslr_slides: dict[cle.Backend, int] = {}
         self._current_slide = None
 
         self._fd_bytes = None
 
         # keep track of the last basic block we hit
-        self.predecessors: List["SimState"] = [None] * keep_predecessors
+        self.predecessors: list["SimState"] = [None] * keep_predecessors
         self.last_state = None
 
         # whether we should follow the trace
@@ -284,7 +284,7 @@ class Tracer(ExplorationTechnique):
             # this is an awful fucking heuristic but it's as good as we've got
             return abs(self._trace[idx] - self._trace[idx + 1]) > 0x1000
 
-    def set_fd_data(self, fd_data: Dict[int, bytes]):
+    def set_fd_data(self, fd_data: dict[int, bytes]):
         """
         Set concrete bytes of various fds read by the program
         """

angr/factory.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union, overload, Type
+from typing import overload
 import logging
 import archinfo
 from archinfo.arch_soot import ArchSoot, SootAddressDescriptor
@@ -6,9 +6,12 @@ from archinfo.arch_soot import ArchSoot, SootAddressDescriptor
 from .sim_state import SimState
 from .calling_conventions import default_cc, SimRegArg, SimStackArg, PointerWrapper, SimCCUnknown
 from .callable import Callable
-from .errors import AngrAssemblyError
+from .errors import AngrAssemblyError, AngrError
 from .engines import UberEngine, ProcedureEngine, SimEngineConcrete, SimEngine
 from .sim_type import SimTypeFunction, SimTypeInt
+from .codenode import HookNode, SyscallNode
+from .block import Block, SootBlock
+from .sim_manager import SimulationManager
 
 try:
     from .engines import UberEnginePcode
@@ -25,7 +28,7 @@ class AngrObjectFactory:
     This factory provides access to important analysis elements.
     """
 
-    def __init__(self, project, default_engine: Optional[Type[SimEngine]] = None):
+    def __init__(self, project, default_engine: type[SimEngine] | None = None):
         if default_engine is None:
             if isinstance(project.arch, archinfo.ArchPcode) and UberEnginePcode is not None:
                 l.warning("Creating project with the experimental 'UberEnginePcode' engine")
@@ -171,9 +174,7 @@ class AngrObjectFactory:
         """
         return self.project.simos.state_call(addr, *args, **kwargs)
 
-    def simulation_manager(
-        self, thing: Optional[Union[List[SimState], SimState]] = None, **kwargs
-    ) -> "SimulationManager":
+    def simulation_manager(self, thing: list[SimState] | SimState | None = None, **kwargs) -> "SimulationManager":
         """
         Constructs a new simulation manager.
 
@@ -289,6 +290,7 @@ class AngrObjectFactory:
         cross_insn_opt=True,
         load_from_ro_regions=False,
         initial_regs=None,
+        skip_stmts=False,
     ) -> "Block": ...
 
     # pylint: disable=unused-argument, no-self-use, function-redefined
@@ -311,6 +313,7 @@ class AngrObjectFactory:
         strict_block_end=None,
         collect_data_refs=False,
         cross_insn_opt=True,
+        skip_stmts=False,
     ) -> "SootBlock": ...
 
     def block(
@@ -333,6 +336,7 @@ class AngrObjectFactory:
         cross_insn_opt=True,
         load_from_ro_regions=False,
         initial_regs=None,
+        skip_stmts=False,
     ):
         if isinstance(self.project.arch, ArchSoot) and isinstance(addr, SootAddressDescriptor):
             return SootBlock(addr, arch=self.project.arch, project=self.project)
@@ -351,13 +355,11 @@ class AngrObjectFactory:
                     "Assembling failed. Please make sure keystone is installed, and the assembly string is correct."
                 )
 
-        if max_size is not None:
-            l.warning('Keyword argument "max_size" has been deprecated for block(). Please use "size" instead.')
-            size = max_size
         return Block(
             addr,
             project=self.project,
             size=size,
+            max_size=max_size,
             byte_string=byte_string,
             vex=vex,
             extra_stop_points=extra_stop_points,
@@ -371,6 +373,7 @@ class AngrObjectFactory:
             cross_insn_opt=cross_insn_opt,
             load_from_ro_regions=load_from_ro_regions,
             initial_regs=initial_regs,
+            skip_stmts=skip_stmts,
         )
 
     def fresh_block(self, addr, size, backup_state=None):
@@ -380,9 +383,3 @@ class AngrObjectFactory:
     cc.SimStackArg = SimStackArg
     callable.PointerWrapper = PointerWrapper
     call_state.PointerWrapper = PointerWrapper
-
-
-from .errors import AngrError
-from .sim_manager import SimulationManager
-from .codenode import HookNode, SyscallNode
-from .block import Block, SootBlock

angr/flirt/__init__.py

@@ -22,11 +22,11 @@ class FlirtSignature:
         platform: str,
         sig_name: str,
         sig_path: str,
-        unique_strings: Optional[Set[str]] = None,
-        compiler: Optional[str] = None,
-        compiler_version: Optional[str] = None,
-        os_name: Optional[str] = None,
-        os_version: Optional[str] = None,
+        unique_strings: set[str] | None = None,
+        compiler: str | None = None,
+        compiler_version: str | None = None,
+        os_name: str | None = None,
+        os_version: str | None = None,
     ):
         self.arch = arch
         self.platform = platform
@@ -49,9 +49,9 @@ class FlirtSignature:
 FS = FlirtSignature
 
 # A dict from architecture names to FLIRT signatures under that architecture. Arch names are always in lower case.
-FLIRT_SIGNATURES_BY_ARCH: Dict[str, List[FlirtSignature]] = defaultdict(list)
-LIBRARY_TO_SIGNATURES: Dict[str, List[FlirtSignature]] = defaultdict(list)
-STRING_TO_LIBRARIES: Dict[str, Set[str]] = defaultdict(set)
+FLIRT_SIGNATURES_BY_ARCH: dict[str, list[FlirtSignature]] = defaultdict(list)
+LIBRARY_TO_SIGNATURES: dict[str, list[FlirtSignature]] = defaultdict(list)
+STRING_TO_LIBRARIES: dict[str, set[str]] = defaultdict(set)
 
 
 def load_signatures(path: str) -> None:

angr/flirt/build_sig.py

@@ -1,5 +1,4 @@
 # pylint:disable=consider-using-with
-from typing import List, Dict
 import json
 import subprocess
 import argparse
@@ -16,7 +15,7 @@ UNIQUE_STRING_COUNT = 20
 MAX_UNIQUE_STRING_LEN = 70
 
 
-def get_basic_info(ar_path: str) -> Dict[str, str]:
+def get_basic_info(ar_path: str) -> dict[str, str]:
     """
     Get basic information of the archive file.
     """
@@ -41,7 +40,7 @@ def get_basic_info(ar_path: str) -> Dict[str, str]:
     }
 
 
-def get_unique_strings(ar_path: str) -> List[str]:
+def get_unique_strings(ar_path: str) -> list[str]:
     """
     For Linux libraries, this method requires ar (from binutils), nm (from binutils), and strings.
     """

angr/keyed_region.py

@@ -1,6 +1,6 @@
 import logging
 import weakref
-from typing import Union, Optional, Tuple, TYPE_CHECKING
+from typing import Union, TYPE_CHECKING
 
 from sortedcontainers import SortedDict
 
@@ -133,7 +133,7 @@ class KeyedRegion:
         self._storage, om, self._phi_node_contains = s
         self._object_mapping = weakref.WeakValueDictionary(om)
 
-    def _get_container(self, offset) -> Tuple[int, Optional[RegionObject]]:
+    def _get_container(self, offset) -> tuple[int, RegionObject | None]:
         try:
             base_offset = next(self._storage.irange(maximum=offset, reverse=True))
         except StopIteration:

angr/knowledge_base/knowledge_base.py

@@ -3,7 +3,7 @@
 from itertools import count
 import logging
 
-from typing import TYPE_CHECKING, TypeVar, Type, Optional
+from typing import TYPE_CHECKING, TypeVar
 
 if TYPE_CHECKING:
     from ..project import Project
@@ -116,7 +116,7 @@ class KnowledgeBase:
 
     K = TypeVar("K", bound=KnowledgeBasePlugin)
 
-    def get_knowledge(self, requested_plugin_cls: Type[K]) -> Optional[K]:
+    def get_knowledge(self, requested_plugin_cls: type[K]) -> K | None:
         """
         Type inference safe method to request a knowledge base plugin
         Explicitly passing the type of the requested plugin achieves two things:
@@ -135,7 +135,7 @@ class KnowledgeBase:
             None,
         )
 
-    def request_knowledge(self, requested_plugin_cls: Type[K]) -> K:
+    def request_knowledge(self, requested_plugin_cls: type[K]) -> K:
         existing = self.get_knowledge(requested_plugin_cls)
         if existing is not None:
             return existing

angr/knowledge_plugins/callsite_prototypes.py

@@ -1,5 +1,3 @@
-from typing import Dict, Tuple, Optional
-
 from .plugin import KnowledgeBasePlugin
 from ..sim_type import SimTypeFunction
 from ..calling_conventions import SimCC
@@ -13,7 +11,7 @@ class CallsitePrototypes(KnowledgeBasePlugin):
     def __init__(self, kb):
         super().__init__(kb=kb)
 
-        self._prototypes: Dict[int, Tuple[SimCC, SimTypeFunction, bool]] = {}
+        self._prototypes: dict[int, tuple[SimCC, SimTypeFunction, bool]] = {}
 
     def set_prototype(
         self,
@@ -24,19 +22,19 @@ class CallsitePrototypes(KnowledgeBasePlugin):
     ) -> None:
         self._prototypes[callsite_block_addr] = cc, prototype, manual
 
-    def get_cc(self, callsite_block_addr: int) -> Optional[SimCC]:
+    def get_cc(self, callsite_block_addr: int) -> SimCC | None:
         try:
             return self._prototypes[callsite_block_addr][0]
         except KeyError:
             return None
 
-    def get_prototype(self, callsite_block_addr: int) -> Optional[SimTypeFunction]:
+    def get_prototype(self, callsite_block_addr: int) -> SimTypeFunction | None:
         try:
             return self._prototypes[callsite_block_addr][1]
         except KeyError:
             return None
 
-    def get_prototype_type(self, callsite_block_addr: int) -> Optional[bool]:
+    def get_prototype_type(self, callsite_block_addr: int) -> bool | None:
         try:
             return self._prototypes[callsite_block_addr][2]
         except KeyError:

angr/knowledge_plugins/cfg/cfg_manager.py

@@ -1,5 +1,4 @@
-from typing import Optional
-from functools import reduce
+from collections import defaultdict
 
 from archinfo.arch_arm import is_arm_arch
 
@@ -53,15 +52,29 @@ class CFGManager(KnowledgeBasePlugin):
         cm.cfgs = dict(map(lambda x: (x[0], x[1].copy()), self.cfgs.items()))
         return cm
 
-    def get_most_accurate(self) -> Optional[CFGModel]:
+    def get_most_accurate(self) -> CFGModel | None:
         """
         :return: The most accurate CFG present in the CFGManager, or None if it does not hold any.
         """
         less_accurate_to_most_accurate = ["CFGFast", "CFGEmulated"]
 
-        # Try to get the most accurate first, then default to the next, ... all the way down to `None`.
-        # Equivalent to `self.cfgs.get(<LAST>, self.cfgs.get(<SECOND LAST>, ... self.cfgs.get(<FIRST>, None)))`.
-        return reduce(lambda acc, cfg: self.cfgs.get(cfg, acc), less_accurate_to_most_accurate, None)
+        sorted_cfgs_by_prefix = defaultdict(list)
+        for key, cfg_model in self.cfgs.items():
+            for prefix in less_accurate_to_most_accurate:
+                if key.startswith(prefix):
+                    the_prefix = prefix
+                    break
+            else:
+                # not found
+                continue
+
+            sorted_cfgs_by_prefix[the_prefix].append((key, cfg_model))
+
+        for key in reversed(less_accurate_to_most_accurate):
+            if key in sorted_cfgs_by_prefix:
+                lst = sorted(sorted_cfgs_by_prefix[key], key=lambda item: item[0])
+                return lst[-1][-1]
+        return None
 
     #
     # Pickling