'Initialize the binary.
:return: None'

def _initialize(self):

    for section in self.project.loader.main_object.sections:
        in_segment = False
        for segment in self.project.loader.main_object.segments:
            segment_addr = segment.vaddr
            if (segment_addr <= section.vaddr < (segment_addr + segment.memsize)):
                in_segment = True
                break
        if (not in_segment):
            continue
        if ((section.vaddr % 32) == 0):
            alignment = 32
        elif ((section.vaddr % 16) == 0):
            alignment = 16
        elif ((section.vaddr % 8) == 0):
            alignment = 8
        elif ((section.vaddr % 4) == 0):
            alignment = 4
        else:
            alignment = 2
        self._section_alignments[section.name] = alignment
    l.debug('Generating    CFG...')
    cfg = self.project.analyses.CFG(normalize=True, resolve_indirect_jumps=True, collect_data_references=True, extra_memory_regions=[(1128775680, (1128775680 + 4096))], data_type_guessing_handlers=[self._sequence_handler, self._cgc_extended_application_handler, self._unknown_data_size_handler])
    self.cfg = cfg
    old_capstone_syntax = self.project.arch.capstone_x86_syntax
    if (old_capstone_syntax is None):
        old_capstone_syntax = 'intel'
    if (self.syntax == 'at&t'):
        self.project.arch.capstone_x86_syntax = 'at&t'
        self.project.factory.default_engine.clear_cache()
    self.symbol_manager = SymbolManager(self, cfg)
    l.debug('Collecting    instruction    addresses...')
    for cfg_node in self.cfg.nodes_iter():
        self.all_insn_addrs |= set(cfg_node.instruction_addrs)
    l.debug('Creating    functions...')
    for f in cfg.kb.functions.values():
        if self.project.is_hooked(f.addr):
            continue
        elif self.project._simos.is_syscall_addr(f.addr):
            continue
        section = next(iter((sec.name for sec in self.project.loader.main_object.sections if ((f.addr >= sec.vaddr) and (f.addr < (sec.vaddr + sec.memsize))))), '.text')
        if (section in ('.got', '.plt', 'init', 'fini')):
            continue
        procedure = Procedure(self, f, section=section)
        self.procedures.append(procedure)
    self.procedures = sorted(self.procedures, key=(lambda x: x.addr))
    has_sections = (len(self.project.loader.main_object.sections) > 0)
    l.debug('Creating    data    entries...')
    for (addr, memory_data) in cfg._memory_data.iteritems():
        if (memory_data.sort in ('code    reference',)):
            continue
        if (memory_data.sort == 'string'):
            (new_sort, new_size) = self._cgc_package_list_identifier(memory_data.address, memory_data.size)
            if (new_sort is not None):
                memory_data = memory_data.copy()
                memory_data.sort = new_sort
        if has_sections:
            section = next(iter((sec for sec in self.project.loader.main_object.sections if (sec.vaddr <= addr < (sec.vaddr + sec.memsize)))), None)
            if ((section is not None) and (section.name not in ('.note.gnu.build-id',))):
                data = Data(self, memory_data, section=section)
                self.data.append(data)
            elif (memory_data.sort == 'segment-boundary'):
                section = next(iter((sec for sec in self.project.loader.main_object.sections if (addr == (sec.vaddr + sec.memsize)))), None)
                if (section is not None):
                    data = Data(self, memory_data, section=section)
                    self.data.append(data)
            else:
                pass
        else:
            segment = next(iter((seg for seg in self.project.loader.main_object.segments if (seg.vaddr <= addr <= (seg.vaddr + seg.memsize)))), None)
            if (segment is not None):
                data = Data(self, memory_data, section_name='.data')
                self.data.append(data)
    section_names_to_ignore = {'.init', '.fini', '.fini_array', '.jcr', '.dynamic', '.got', '.got.plt', '.eh_frame_hdr', '.eh_frame', '.rel.dyn', '.rel.plt', '.rela.dyn', '.rela.plt', '.dynstr', '.dynsym', '.interp', '.note.ABI-tag', '.note.gnu.build-id', '.gnu.hash', '.gnu.version', '.gnu.version_r'}
    all_data_addrs = set((d.addr for d in self.data))
    all_procedure_addrs = set((f.addr for f in self.procedures))
    all_addrs = (all_data_addrs | all_procedure_addrs)
    if has_sections:
        for section in self.project.loader.main_object.sections:
            if (section.name in section_names_to_ignore):
                continue
            for segment in self.project.loader.main_object.segments:
                segment_start = segment.vaddr
                segment_end = (segment_start + segment.memsize)
                if (segment_start <= section.vaddr < segment_end):
                    break
            else:
                continue
            section_boundary_addr = (section.vaddr + section.memsize)
            if (section_boundary_addr not in all_addrs):
                data = Data(self, addr=section_boundary_addr, size=0, sort='segment-boundary', section_name=section.name)
                self.data.append(data)
                all_data_addrs.add(section_boundary_addr)
    self.data = sorted(self.data, key=(lambda x: x.addr))
    data_indices_to_remove = set()
    for (i, data) in enumerate(self.data):
        if (i in data_indices_to_remove):
            continue
        if (i < (len(self.data) - 1)):
            if ((data.addr + data.size) > self.data[(i + 1)].addr):
                new_size = (self.data[(i + 1)].addr - data.addr)
                if (data.sort == 'pointer-array'):
                    pointer_size = (self.project.arch.bits / 8)
                    if ((new_size % pointer_size) != 0):
                        data_indices_to_remove.add((i + 1))
                        source_addr = self.data[(i + 1)].memory_data.pointer_addr
                        if (source_addr is not None):
                            original_data = next((d for d in self.data if (d.addr <= source_addr < (d.addr + d.size))), None)
                            if (original_data is not None):
                                original_data.desymbolize()
                        continue
                data.shrink(new_size)
        if ((data.sort == 'unknown') and (data.size == 0)):
            if ((i + 1) == len(self.data)):
                if (data.section is None):
                    continue
                data.size = ((data.section.vaddr + data.section.memsize) - data.addr)
            else:
                data.size = (self.data[(i + 1)].addr - data.addr)
    for i in sorted(data_indices_to_remove, reverse=True):
        self.data = (self.data[:i] + self.data[(i + 1):])
    self.data = [d for d in self.data if (d.section_name not in section_names_to_ignore)]
    if (self.project.arch.capstone_x86_syntax != old_capstone_syntax):
        self.project.arch.capstone_x86_syntax = old_capstone_syntax
        self.project.factory.default_engine.clear_cache()
    l.debug('Initialized.')
