docs: def get_any_node(self, addr, is_syscall=None, anyaddr=False, force_fastpath=False):
          """
          Get an arbitrary CFGNode (without considering their contexts) from our graph.
  
          :param int addr:        Address of the beginning of the basic block. Set anyaddr to True to support arbitrary
                                  address.
          :param bool is_syscall: Whether you want to get the syscall node or any other node. This is due to the fact that
                                  syscall SimProcedures have the same address as the targer it returns to.
                                  None means get either, True means get a syscall node, False means get something that isn't
                                  a syscall node.
          :param bool anyaddr:    If anyaddr is True, then addr doesn't have to be the beginning address of a basic
                                  block. By default the entire graph.nodes() will be iterated, and the first node
                                  containing the specific address is returned, which is slow. If you need to do many such
                                  queries, you may first call `generate_index()` to create some indices that may speed up the
                                  query.
          :param bool force_fastpath: If force_fastpath is True, it will only perform a dict lookup in the _nodes_by_addr
                                      dict.
          :return: A CFGNode if there is any that satisfies given conditions, or None otherwise
          """
  
          # fastpath: directly look in the nodes list
          if not anyaddr:
              try:
                  return self._nodes_by_addr[addr][0]
              except (KeyError, IndexError):
                  pass
  
          if force_fastpath:
              return None
  
          # slower path
          #if self._node_lookup_index is not None:
          #    pass
  
          # the slowest path
          # try to show a warning first
          # TODO: re-enable it once the segment tree is implemented
          #if self._node_lookup_index_warned == False:
          #    l.warning('Calling get_any_node() with anyaddr=True is slow on large programs. '
          #              'For better performance, you may first call generate_index() to generate some indices that may '
          #              'speed the node lookup.')
          #    self._node_lookup_index_warned = True
  
          for n in self.graph.nodes():
              if self.ident == "CFGEmulated":
                  cond = n.looping_times == 0
              else:
                  cond = True
              if anyaddr and n.size is not None:
                  cond = cond and n.addr <= addr < n.addr + n.size
              else:
                  cond = cond and (addr == n.addr)
              if cond:
                  if is_syscall is None:
                      return n
                  if n.is_syscall == is_syscall:
                      return n
  
          return None