':param binary:                  The binary to recover CFG on. By default the main binary is used.
:param iterable regions:        A list of tuples in the form of (start address, end address) describing memory
regions that the CFG should cover.
:param bool pickle_intermediate_results: If we want to store the intermediate results or not.
:param bool symbols:            Get function beginnings from symbols in the binary.
:param bool function_prologues: Scan the binary for function prologues, and use those positions as function
beginnings
:param bool resolve_indirect_jumps: Try to resolve indirect jumps. This is necessary to resolve jump targets
from jump tables, etc.
:param bool force_segment:      Force CFGFast to rely on binary segments instead of sections.
:param bool force_complete_scan:    Perform a complete scan on the binary and maximize the number of identified
code blocks.
:param bool collect_data_references: If CFGFast should collect data references from individual basic blocks or
not.
:param bool extra_cross_references:  True if we should collect data references for all places in the program
that access each memory data entry, which requires more memory, and is
noticeably slower. Setting it to False means each memory data entry has at
most one reference (which is the initial one).
:param bool normalize:          Normalize the CFG as well as all function graphs after CFG recovery.
:param bool start_at_entry:     Begin CFG recovery at the entry point of this project. Setting it to False
prevents CFGFast from viewing the entry point as one of the starting points of
code scanning.
:param list function_starts:    A list of extra function starting points. CFGFast will try to resume scanning
from each address in the list.
:param list extra_memory_regions: A list of 2-tuple (start-address, end-address) that shows extra memory
regions. Integers falling inside will be considered as pointers.
:param list indirect_jump_resolvers: A custom list of indirect jump resolvers. If this list is None or empty,
default indirect jump resolvers specific to this architecture and binary
types will be loaded.
:param int start:               (Deprecated) The beginning address of CFG recovery.
:param int end:                 (Deprecated) The end address of CFG recovery.
:param CFGArchOptions arch_options: Architecture-specific options.
:param dict extra_arch_options: Any key-value pair in kwargs will be seen as an arch-specific option and will
be used to set the option value in self._arch_options.
Extra parameters that angr.Analysis takes:
:param progress_callback:       Specify a callback function to get the progress during CFG recovery.
:param bool show_progressbar:   Should CFGFast show a progressbar during CFG recovery or not.
:return: None'

def __init__(self, binary=None, regions=None, pickle_intermediate_results=False, symbols=True, function_prologues=True, resolve_indirect_jumps=True, force_segment=False, force_complete_scan=True, indirect_jump_target_limit=100000, collect_data_references=False, extra_cross_references=False, normalize=False, start_at_entry=True, function_starts=None, extra_memory_regions=None, data_type_guessing_handlers=None, arch_options=None, indirect_jump_resolvers=None, start=None, end=None, **extra_arch_options):

    ForwardAnalysis.__init__(self, allow_merging=False)
    CFGBase.__init__(self, 'fast', 0, normalize=normalize, binary=binary, force_segment=force_segment)
    if ((self.project.loader._auto_load_libs is True) and (end is None) and (len(self.project.loader.all_objects) > 3)):
        l.warning('"auto_load_libs"    is    enabled.    With    libraries    loaded    in    project,    CFGFast    will    cover    libraries,    which    may    take    significantly    more    time    than    expected.    You    may    reload    the    binary    with    "auto_load_libs"    disabled,    or    specify    "regions"    to    limit    the    scope    of    CFG    recovery.')
    if ((start is not None) or (end is not None)):
        l.warning('"start"    and    "end"    are    deprecated    and    will    be    removed    soon.    Please    use    "regions"    to    specify    one    or    more    memory    regions    instead.')
        if (regions is None):
            regions = [(start, end)]
        else:
            l.warning('"regions",    "start",    and    "end"    are    all    specified.    Ignoring    "start"    and    "end".')
    self._regions = (regions if (regions is not None) else self._executable_memory_regions(None, force_segment))
    self._regions = sorted(self._regions, key=(lambda x: x[0]))
    self._pickle_intermediate_results = pickle_intermediate_results
    self._indirect_jump_target_limit = indirect_jump_target_limit
    self._collect_data_ref = collect_data_references
    self._use_symbols = symbols
    self._use_function_prologues = function_prologues
    self._resolve_indirect_jumps = resolve_indirect_jumps
    self._force_complete_scan = force_complete_scan
    self._start_at_entry = start_at_entry
    self._extra_function_starts = function_starts
    self._extra_memory_regions = extra_memory_regions
    self._extra_cross_references = extra_cross_references
    try:
        self._arch_options = (arch_options if (arch_options is not None) else CFGArchOptions(self.project.arch, **extra_arch_options))
    except KeyError:
        raise
    self._data_type_guessing_handlers = ([] if (data_type_guessing_handlers is None) else data_type_guessing_handlers)
    l.debug('CFG    recovery    covers    %d    regions:', len(self._regions))
    for (start_addr, end_addr) in self._regions:
        l.debug('...    %#x    -    %#x', start_addr, end_addr)
    self._memory_data = {}
    self.insn_addr_to_memory_data = {}
    self._initial_state = None
    self._next_addr = None
    self._seg_list = SegmentList()
    self._read_addr_to_run = defaultdict(list)
    self._write_addr_to_run = defaultdict(list)
    self._indirect_jumps_to_resolve = set()
    self._jump_tables = {}
    self._function_addresses_from_symbols = self._func_addrs_from_symbols()
    self._function_prologue_addrs = None
    self._remaining_function_prologue_addrs = None
    self.timeless_indirect_jump_resolvers = []
    self.indirect_jump_resolvers = []
    if (not indirect_jump_resolvers):
        indirect_jump_resolvers = default_indirect_jump_resolvers(self.project.arch, self._binary, self.project)
    if indirect_jump_resolvers:
        for ijr in indirect_jump_resolvers:
            if ijr.timeless:
                self.timeless_indirect_jump_resolvers.append(ijr)
            elif self._resolve_indirect_jumps:
                self.indirect_jump_resolvers.append(ijr)
    l.info('Loaded    %d    indirect    jump    resolvers    (%d    timeless,    %d    generic).', (len(self.timeless_indirect_jump_resolvers) + len(self.indirect_jump_resolvers)), len(self.timeless_indirect_jump_resolvers), len(self.indirect_jump_resolvers))
    self._pending_jobs = None
    self._traced_addresses = None
    self._function_returns = None
    self._function_exits = None
    self._graph = None
    self._analyze()
