//! assert_eq!(p.interpreter().unwrap().to_bytes_with_nul(), new_interp);

//! assert_eq!(p.interpreter().unwrap().unwrap().to_bytes_with_nul(), new_interp);

    #[error("Wrong file type")]
    WrongMagic,

    data: Endianness,

    pub data: Endianness,

#[derive(Debug, Copy, Clone)]

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]

        } else {
            panic!()
        }
    }
}
impl Endian<u16> {
    fn from(id: Endianness, u: u16) -> Self {
        if id == Endianness::LITTLE {
            Endian(u.to_le())
        } else if id == Endianness::BIG {
            Endian(u.to_be())

        } else {
            panic!()
        }
    }
}
impl Endian<Pht> {
    fn from(id: Endianness, u: Pht) -> Self {
        if id == Endianness::LITTLE {
            Endian(Pht(u.0.to_le()))
        } else if id == Endianness::BIG {
            Endian(Pht(u.0.to_be()))
        } else {
            panic!()
        }
    }
}
impl Endian<DynTag64> {
    fn from(id: Endianness, u: DynTag64) -> Self {
        if id == Endianness::LITTLE {
            Endian(DynTag64(u.0.to_le()))
        } else if id == Endianness::BIG {
            Endian(DynTag64(u.0.to_be()))
        } else {
            panic!()
        }
    }
}
impl Endian<DynTag32> {
    fn from(id: Endianness, u: DynTag32) -> Self {
        if id == Endianness::LITTLE {
            Endian(DynTag32(u.0.to_le()))
        } else if id == Endianness::BIG {
            Endian(DynTag32(u.0.to_be()))

impl EndianT for Pht {
    fn endian(e: Endian<Self>, id: Endianness) -> Self {
        if id == Endianness::LITTLE {
            Pht(u32::from_le(e.0 .0))
        } else if id == Endianness::BIG {
            Pht(u32::from_be(e.0 .0))
        } else {
            panic!()
        }
    }
}

    fn set_offset(&mut self, h: Endianness, u: usize) {

    pub fn set_offset(&mut self, h: Endianness, u: usize) {

        }
    }
    pub fn set_addr(&mut self, h: Endianness, u: usize) {
        match self {
            SectionHeaderMut_::B32(s) => s.addr = <Endian<u32>>::from(h, u as u32),
            SectionHeaderMut_::B64(s) => s.addr = <Endian<u64>>::from(h, u as u64),
        }
    }
    pub fn offset(&self, h: Endianness) -> u64 {
        match self {
            SectionHeaderMut_::B32(s) => EndianT::endian(s.offset, h) as u64,
            SectionHeaderMut_::B64(s) => EndianT::endian(s.offset, h),

    pub fn addr(&self, h: Endianness) -> u64 {
        match self {
            SectionHeaderMut_::B32(s) => EndianT::endian(s.addr, h) as u64,
            SectionHeaderMut_::B64(s) => EndianT::endian(s.addr, h),
        }
    }

    fn offset(&self, h: Endianness) -> u64 {

    fn set_filesz(&mut self, h: Endianness, u: usize) {

            ProgramHeaderMut_::B32(s) => EndianT::endian(s.offset, h) as u64,
            ProgramHeaderMut_::B64(s) => EndianT::endian(s.offset, h),

            ProgramHeaderMut_::B32(s) => s.filesz = <Endian<u32>>::from(h, u as u32),
            ProgramHeaderMut_::B64(s) => s.filesz = <Endian<u64>>::from(h, u as u64),

    fn set_filesz(&mut self, h: Endianness, u: usize) {

    pub fn set_vaddr(&mut self, h: Endianness, u: usize) {

            ProgramHeaderMut_::B32(s) => s.filesz = <Endian<u32>>::from(h, u as u32),
            ProgramHeaderMut_::B64(s) => s.filesz = <Endian<u64>>::from(h, u as u64),

            ProgramHeaderMut_::B32(s) => s.vaddr = <Endian<u32>>::from(h, u as u32),
            ProgramHeaderMut_::B64(s) => s.vaddr = <Endian<u64>>::from(h, u as u64),

    fn set_offset(&mut self, h: Endianness, u: usize) {

    pub fn set_offset(&mut self, h: Endianness, u: usize) {

        }
    }
    pub fn set_type(&mut self, h: Endianness, u: Pht) {
        match self {
            ProgramHeaderMut_::B32(s) => s.type_ = <Endian<Pht>>::from(h, u),
            ProgramHeaderMut_::B64(s) => s.type_ = <Endian<Pht>>::from(h, u),
        }
    }
    pub fn set_flags(&mut self, h: Endianness, u: u32) {
        match self {
            ProgramHeaderMut_::B32(s) => s.flags32 = <Endian<u32>>::from(h, u),
            ProgramHeaderMut_::B64(s) => s.flags64 = <Endian<u32>>::from(h, u),
        }
    }
    pub fn set_align(&mut self, h: Endianness, u: u64) {
        match self {
            ProgramHeaderMut_::B32(s) => s.align = <Endian<u32>>::from(h, u as u32),
            ProgramHeaderMut_::B64(s) => s.align = <Endian<u64>>::from(h, u),
        }
    }
    fn type_(&self, id: Endianness) -> Pht {
        match self {
            ProgramHeaderMut_::B32(h) => EndianT::endian(h.type_, id),
            ProgramHeaderMut_::B64(h) => EndianT::endian(h.type_, id),
        }
    }
    pub fn filesz(&self, h: Endianness) -> u64 {
        match self {
            ProgramHeaderMut_::B32(s) => EndianT::endian(s.filesz, h) as u64,
            ProgramHeaderMut_::B64(s) => EndianT::endian(s.filesz, h),
        }
    }
    pub fn memsz(&self, h: Endianness) -> u64 {
        match self {
            ProgramHeaderMut_::B32(s) => EndianT::endian(s.memsz, h) as u64,
            ProgramHeaderMut_::B64(s) => EndianT::endian(s.memsz, h),

        }
    }
    fn type_(&self, id: Endianness) -> Pht {
        match self {
            ProgramHeaderBits::B32(h) => EndianT::endian(h.type_, id),
            ProgramHeaderBits::B64(h) => EndianT::endian(h.type_, id),

    pub fn align(&self, h: Endianness) -> u64 {
        match self {
            ProgramHeaderBits::B32(s) => EndianT::endian(s.align, h) as u64,
            ProgramHeaderBits::B64(s) => EndianT::endian(s.align, h),
        }
    }

        }
    }
    pub fn addr(&self, h: Endianness) -> u64 {
        match self {
            SectionHeader_::B32(s) => EndianT::endian(s.addr, h) as u64,
            SectionHeader_::B64(s) => EndianT::endian(s.addr, h),

    f: Option<&'a std::fs::File>,

    f: &'a std::fs::File,

    pub fn open(file: &'f std::fs::File) -> Result<Self, std::io::Error> {

    pub fn open(file: &'f std::fs::File) -> Result<Self, Error> {

        Ok(Elf {

        let e = Elf {

            f: Some(file),

            f: file,

        })

        };
        if e.id().magic == [0x7f, 0x45, 0x4c, 0x46] {
            Ok(e)
        } else {
            Err(Error::WrongMagic)
        }

            x = x.max(off as usize + sz as usize);

    /// Paress the sections relevant for linking (.interp, .dynstr, .dynamic).

    /// Parses the sections relevant for linking (.interp, .dynstr, .dynamic).

        let mut interp = &[][..];

        let mut interp = None;

                interp = &self.map[offset..offset + size];

                interp = Some(&self.map[offset..offset + size]);

                dynamic = match id.class {
                    Bits::B32 => {
                        assert_eq!(offset % std::mem::align_of::<Elf32Dyn>(), 0);
                        assert!(offset + size <= self.map.len());
                        Dynamic::B32(unsafe {
                            std::slice::from_raw_parts(
                                self.map.as_ptr().add(offset) as *const u8 as *const Elf32Dyn,
                                size / std::mem::size_of::<Elf32Dyn>(),
                            )
                        })
                    }
                    Bits::B64 => Dynamic::B64(unsafe {
                        assert_eq!(offset % std::mem::align_of::<Elf64Dyn>(), 0);
                        assert!(offset + size <= self.map.len());
                        std::slice::from_raw_parts(
                            self.map.as_ptr().add(offset) as *const u8 as *const Elf64Dyn,
                            size / std::mem::size_of::<Elf64Dyn>(),
                        )
                    }),
                    _ => panic!(),
                };

                assert!(offset + size <= self.map.len());
                dynamic =
                    unsafe { dynamic_from_raw(id.class, self.map.as_ptr().add(offset), size) };

            data: id.data,

            if names

            let n = names

                .to_bytes()
                == name
            {

                .to_bytes();
            if n == name {

        let mut next_off = header.shoff(id);
        for sec in self.sections::<U>() {
            let s: u64 = EndianT::endian(sec.offset, id).into();

        let mut next_off = self.f.metadata().unwrap().len();
        for s in self
            .sections::<U>()
            .iter()
            .map(|sec| EndianT::endian(sec.offset, id).into())
            .chain(std::iter::once(header.shoff(id)))
        {

    pub fn update_section(&mut self, name: &[u8], new: &[u8]) -> Result<usize, Error> {

    fn update_section(&mut self, name: &[u8], new: &[u8]) -> Result<(), Error> {

            self.find_section::<u64>(name)?

            self.find_section::<u32>(name)?

            Ok(0)

            Ok(())

            Ok(self.update_section_allocate(id, new, interp_i, off as u64))

            Ok(self.update_section_allocate(id, new, interp_i))

        off: u64,
    ) -> usize {

    ) {

        let shnum = h.shnum(id);
        let class = self.id().class;

        // First find a large enough deleted section = gap
        // between sections.

        let mut sections: Vec<_> = (0..h.shnum(id))
            .map(|p_| {
                let sh = self.section(p_ as usize);
                (sh.offset(id) as usize, sh.size(id) as usize, p_ as isize)
            })
            .collect();
        sections.push((
            h.shoff(id) as usize,
            h.shentsize(id) as usize * h.shnum(id) as usize,
            -1,
        ));
        sections.sort_by_key(|(o, _, _)| *o);

        let mut sections: Vec<_> = if class == Bits::B32 {
            self.sections::<u32>()
                .iter()
                .map(|s| {
                    (
                        EndianT::endian(s.offset, id) as usize,
                        EndianT::endian(s.size, id) as usize,
                    )
                })
                .collect()
        } else {
            self.sections::<u64>()
                .iter()
                .map(|s| {
                    (
                        EndianT::endian(s.offset, id) as usize,
                        EndianT::endian(s.size, id) as usize,
                    )
                })
                .collect()
        };
        sections.sort();

        let s = sections
            .iter()
            .position(|(_, _, i)| *i == interp_i as isize)
            .unwrap();
        let mut last_vaddr = 0;
        let mut page_size = 0;
        let mut programs: Vec<_> = (0..h.phnum(id))
            .map(|p_| {
                let sh = self.program(p_ as usize);
                last_vaddr = last_vaddr.max((sh.vaddr(id) + sh.memsz(id)) as usize);
                let type_ = sh.type_(id);
                if type_ == Pht::LOAD {
                    page_size = sh.align(id) as usize;
                }
                (
                    sh.offset(id) as usize,
                    sh.filesz(id) as usize,
                    type_,
                    sh.flags(id),
                    p_ as isize,
                )
            })
            .collect();
        let rounded_last_vaddr = align_next(last_vaddr as usize, page_size);

        let extra_size = new_len;
        let extra_size = match class {
            Bits::B32 => (extra_size + 3) & !3,
            Bits::B64 => (extra_size + 7) & !7,
            _ => panic!(),
        };

        programs.sort_by_key(|(o, _, _, _, _)| *o);

        let mut end = 0;
        let mut new_offset = h.shoff(id) as usize;
        let mut gap = usize::MAX;

        let s_off = sections[s].0;
        let p = programs
            .iter()
            .position(|(o, e, t, _, _)| *o <= s_off && *o + *e > s_off && *t == Pht::LOAD)
            .expect("Section isn't loaded, no need to do anything");

        for (off, len) in sections.iter() {
            if end > 0 && *off >= end + extra_size && *off - (end + extra_size) < gap {
                new_offset = end;
                gap = *off - (end + extra_size)
            }
            end = align_next(*off + len, 8)
        }

        let s_len = sections[s].1;

        let shentsize = h.shentsize(id);
        let section_table_len = shnum as usize * shentsize as usize;

        let end0 = s_off + s_len;
        let mut end = end0;

        let total = shoff + section_table_len;

        let mut new_offset = shoff;

        assert!(extra_size + total <= self.map.len());

        for (off, len, _) in sections.iter().skip(s + 1) {
            if *off >= end + new_len {
                // Is this the same segment ?
                if end <= programs[p].0 + programs[p].1 {
                    new_offset = end;
                    break;
                }
            }
            end = end.max(*off + *len)
        }

        if new_offset == shoff {
            // No space was found.
            assert!(shoff as usize + extra_size + section_table_len <= self.map.len());

        if new_offset < shoff {
            // Just write the section here and return.

                // Moving just the section header table

                    self.map.as_ptr().add(shoff as usize),
                    self.map.as_mut_ptr().add(shoff as usize + extra_size),
                    section_table_len,

                    new.as_ptr(),
                    self.map.as_mut_ptr().add(new_offset),
                    new.len(),
                )
            }
            let mut sec = self.section_mut(interp_i);
            let addr = new_offset + sec.addr(id) as usize - sec.offset(id) as usize;
            sec.set_addr(id, addr);
            sec.set_offset(id, new_offset);
            sec.set_size(id, new.len());
            if new_offset == programs[p].0 + programs[p].1 {
                // Extend segment
                let mut p = self.program_mut(programs[p].4 as usize);
                p.set_filesz(id, p.filesz(id) as usize + new.len());
                p.set_memsz(id, p.memsz(id) as usize + new.len());
            }
            // If the section has its own segment, update that too.
            for (o, l, _, _, p) in &programs {
                if *o == s_off && *l == s_len {
                    let mut p = self.program_mut(*p as usize);
                    p.set_offset(id, new_offset);
                    p.set_filesz(id, new.len());
                    p.set_memsz(id, new.len());
                    p.set_vaddr(id, addr);
                }
            }
        } else {
            // Add a segment at the end, possibly moving the first
            // section after the section header table.
            let pht_end = h.phoff(id) as usize + h.phentsize(id) as usize * h.phnum(id) as usize;
            // Combien de sections doit-on déplacer pour ajouter notre
            // segment ?
            let first_section_after_pht = sections
                .iter()
                .filter_map(|(o, _, _)| {
                    if *o >= pht_end as usize {
                        Some(*o)
                    } else {
                        None
                    }
                })
                .min()
                .unwrap_or(0);
            let new_offset;
            if first_section_after_pht < pht_end + h.phentsize(id) as usize {
                // In the absolute worst case, we need 3 new LOAD
                // segments: our new one, and then one for each end of
                // the sequence of sections we need to move to make
                // room for the program headers.
                let new_segments = 3;
                let limit = pht_end + new_segments * h.phentsize(id) as usize;
                let mut init = 0;
                let mut end = 0;
                let mut init_off = 0;
                let mut end_off = 0;
                for (n, (o, _, _)) in sections.iter().enumerate() {
                    if *o >= pht_end && init == 0 {
                        init = n;
                        init_off = *o;
                    }
                    if *o >= limit && end == 0 {
                        end = n;
                        end_off = *o;
                    }
                }
                let current_len = self.f.metadata().unwrap().len() as usize;
                let rounded_len = align_next(current_len, page_size);
                let rounded_moved =
                    align_next(end_off - init_off, page_size as usize);
                new_offset = rounded_len as usize + rounded_moved;
                // New pages for the moved + new pages for new.
                self.f
                    .set_len((rounded_len + rounded_moved + new.len()) as u64)
                    .unwrap();
                self.map = unsafe { memmap::MmapOptions::new().map_mut(self.f).unwrap() };
                unsafe {
                    std::ptr::copy(
                        self.map.as_ptr().add(init_off),
                        self.map.as_mut_ptr().add(rounded_len as usize),
                        end_off - init_off,
                    );
                }
                let mut pi = 0;
                for s in init..end {
                    let sec_n = sections[s].2;
                    let mut sec = self.section_mut(sec_n as usize);
                    let new_offset = rounded_len as usize + sec.offset(id) as usize - init_off;
                    sec.set_offset(id, new_offset);
                    sec.set_addr(
                        id,
                        new_offset + rounded_last_vaddr - rounded_len as usize,
                    );
                    while pi < programs.len() && programs[pi].0 <= sections[s].0 {
                        if programs[pi].0 == sections[s].0 && programs[pi].2 != Pht::LOAD {
                            let mut p = self.program_mut(programs[pi].4 as usize);
                            p.set_offset(id, new_offset);
                            p.set_vaddr(
                                id,
                                new_offset + rounded_last_vaddr - rounded_len as usize,
                            );
                        }
                        pi += 1;
                    }
                }
                self.add_load_segment(
                    id,
                    rounded_len as usize,
                    end_off - init_off,
                    rounded_last_vaddr,
                    4,
                    page_size,

                self.header_mut().set_shoff(id, shoff as usize + extra_size);

                last_vaddr = rounded_last_vaddr + rounded_moved as usize;
            } else {
                let current_len = self.f.metadata().unwrap().len() as usize;
                let rounded_len = align_next(current_len, page_size);
                new_offset = rounded_len;
                // New pages for new.
                self.f.set_len((rounded_len + new.len()) as u64).unwrap();
                self.map = unsafe { memmap::MmapOptions::new().map_mut(self.f).unwrap() };

        }

        assert!(new_offset as usize + new.len() <= self.map.len());
        unsafe {
            // Write the new value
            self.map
                .as_mut_ptr()
                .add(new_offset as usize)
                .write_bytes(0, extra_size);
            std::ptr::copy(
                new.as_ptr() as *const i8,
                self.map.as_mut_ptr().add(new_offset as usize) as *mut i8,
                new.len(),
            );

            let mut sec = self.section_mut(interp_i);
            sec.set_offset(id, new_offset);
            sec.set_size(id, new.len());
            sec.set_addr(id, last_vaddr as usize);
            unsafe {
                std::ptr::copy(
                    new.as_ptr(),
                    self.map.as_mut_ptr().add(new_offset),
                    new.len(),
                )
            }
            self.add_load_segment(id, new_offset, new.len(), last_vaddr as usize, 4, page_size);

    }

        // Update the section
        let mut s = self.section_mut(interp_i as usize);
        s.set_offset(id, new_offset);
        s.set_size(id, new_len);
        // Do the same in the program header table
        let phnum = self.header().phnum(id);
        for i in 0..phnum {
            let mut p = self.program_mut(i as usize);
            let p_off = p.offset(id);
            if p_off == off {
                // the new offset is the old shoff
                p.set_offset(id, new_offset as usize);
                p.set_filesz(id, new_len);
                p.set_memsz(id, new_len);

    fn add_load_segment(
        &mut self,
        id: Endianness,
        offset: usize,
        len: usize,
        vaddr: usize,
        flags: u32,
        align: usize,
    ) {
        let mut hh = self.header_mut();
        let phentsize = hh.phentsize(id) as usize;
        let phnum = hh.phnum(id);
        hh.set_phnum(id, phnum + 1);
        let mut p = self.program_mut(phnum as usize);
        p.set_offset(id, offset);
        p.set_memsz(id, len);
        p.set_filesz(id, len);
        p.set_vaddr(id, vaddr);
        p.set_type(id, Pht::LOAD);
        p.set_flags(id, flags);
        p.set_align(id, align as u64);
        for p in 0..phnum {
            let mut p = self.program_mut(p as usize);
            if p.type_(id) == Pht::PHDR {
                p.set_filesz(id, p.filesz(id) as usize + phentsize);
                p.set_memsz(id, p.memsz(id) as usize + phentsize);
                break;

        extra_size

        remove_trailing_needed_runpath(dynstr, dynamic);

        remove_trailing_needed_runpath(parsed.data, dynstr, dynamic);
        let id = self.id().data;

                set_runpath(dynstr, dynamic, &runpath)

                set_runpath(id, dynstr, dynamic, &runpath)

            set_runpath(dynstr, dynamic, &self.new_runpath)

            set_runpath(id, dynstr, dynamic, &self.new_runpath)

        let id = self.id().data;

            retain_needed(dynstr, dynamic, needed);

            retain_needed(id, dynstr, dynamic, needed);

    /// Run the updates, potentially extending the underlying ELF file.

        let extra_room = ((self.new_interp.len() + 7) & !7)
            + dynstr_owned.len()
            + dynamic_owned.as_bytes().len();
        let f = self.f.take().unwrap();

        std::mem::drop(self);
        let current_len = f.metadata()?.len();
        f.set_len(current_len + extra_room as u64)?;
        let mut elf = Elf::open(f)?;

        let id = self.id().data;
        if !new_runpath.is_empty() {
            set_runpath(id, &mut dynstr_owned, &mut dynamic_owned, &new_runpath)
        }

        let mut extra = 0;

            extra += elf.update_section(b".interp", &new_interp).unwrap()

            self.update_section(b".interp", &new_interp).unwrap()

        if !new_runpath.is_empty() {
            set_runpath(&mut dynstr_owned, &mut dynamic_owned, &new_runpath)

        if new_needed.is_some() || !new_runpath.is_empty() {
            self.update_section(b".dynstr", &dynstr_owned).unwrap();
            self
                .update_section(b".dynamic", dynamic_owned.as_bytes())
                .unwrap();

        if new_needed.is_some() || !new_runpath.is_empty() {
            extra += elf.update_section(b".dynstr", &dynstr_owned).unwrap()
                + elf
                    .update_section(b".dynamic", dynamic_owned.as_bytes())
                    .unwrap();

        let id = self.id().data;
        match dynamic_owned {
            OwnedDynamic::B32(ref mut v) => {
                for t in v.iter_mut() {
                    self.update_dynamic::<u32>(id, t)
                }
            }
            OwnedDynamic::B64(ref mut v) => {
                for t in v.iter_mut() {
                    self.update_dynamic::<u64>(id, t)
                }
            }

        f.set_len(current_len + extra as u64)?;

        self.update_section(b".dynamic", dynamic_owned.as_bytes())
            .unwrap();
        // f.set_len(current_len + extra as u64)?;

    fn update_dynamic<F: Flags>(&self, id: Endianness, f: &mut F::Dyn) {
        if F::tag(id, *f) == F::dt_strtab() {
            let s = self.find_section::<F>(b".dynstr").unwrap().unwrap();
            let sec = self.section(s);
            F::set_d_un(id, f, sec.addr(id) as usize)
        } else if F::tag(id, *f) == F::dt_strsz() {
            let s = self.find_section::<F>(b".dynstr").unwrap().unwrap();
            let sec = self.section(s);
            F::set_d_un(id, f, sec.size(id) as usize)
        }
    }

    data: Endianness,

    interp: &'a [u8],

    interp: Option<&'a [u8]>,

fn remove_trailing_needed_runpath_<F: Flags>(dynstr: &mut Vec<u8>, dynamic: &mut Vec<F::Dyn>) {

fn remove_trailing_needed_runpath_<F: Flags>(
    id: Endianness,
    dynstr: &mut Vec<u8>,
    dynamic: &mut Vec<F::Dyn>,
) {

            if F::tag(*x) == F::dt_needed() || F::tag(*x) == F::dt_runpath() {

            if F::tag(id, *x) == F::dt_needed() || F::tag(id, *x) == F::dt_runpath() {

    off.sort_by_key(|x| F::d_un(*x));

    off.sort_by_key(|x| F::d_un(id, *x));

        let c = CStr::from_bytes_until_nul(&dynstr[F::d_un(p) as usize..]).unwrap();

        let c = CStr::from_bytes_until_nul(&dynstr[F::d_un(id, p) as usize..]).unwrap();

        if F::d_un(p) as usize + len >= dynstr.len() {
            dynstr.truncate(F::d_un(p) as usize);

        if F::d_un(id, p) as usize + len >= dynstr.len() {
            dynstr.truncate(F::d_un(id, p) as usize);

fn remove_trailing_needed_runpath(dynstr: &mut Vec<u8>, dynamic: &mut OwnedDynamic) {

fn remove_trailing_needed_runpath(
    id: Endianness,
    dynstr: &mut Vec<u8>,
    dynamic: &mut OwnedDynamic,
) {

        OwnedDynamic::B32(b) => remove_trailing_needed_runpath_::<u32>(dynstr, b),
        OwnedDynamic::B64(b) => remove_trailing_needed_runpath_::<u64>(dynstr, b),

        OwnedDynamic::B32(b) => remove_trailing_needed_runpath_::<u32>(id, dynstr, b),
        OwnedDynamic::B64(b) => remove_trailing_needed_runpath_::<u64>(id, dynstr, b),

fn set_runpath_<F: Flags>(dynstr: &mut Vec<u8>, dynamic: &mut Vec<F::Dyn>, rpath: &[u8]) {

fn set_runpath_<F: Flags>(
    id: Endianness,
    dynstr: &mut Vec<u8>,
    dynamic: &mut Vec<F::Dyn>,
    rpath: &[u8],
) {

        if F::tag(*x) == F::dt_runpath() {

        if F::tag(id, *x) == F::dt_runpath() {

            let current = &mut dynstr[F::d_un(*x)..];

            let current = &mut dynstr[F::d_un(id, *x)..];

                F::set_d_un(x, offset);

                F::set_d_un(id, x, offset);

        } else if F::tag(*x) != F::tag_nul() {

        } else if F::tag(id, *x) != F::tag_nul() {

    dynamic.insert(n, F::dyn_(F::dt_runpath(), offset))

    if F::tag(id, dynamic[dynamic.len() - 2]) == F::tag_nul() {
        dynamic.pop();
    }
    dynamic.insert(n + 1, F::dyn_(id, F::dt_runpath(), offset));

fn retain_needed(dynstr: &mut Vec<u8>, dynamic: &mut OwnedDynamic, needed: &mut Vec<Vec<u8>>) {

fn retain_needed(
    id: Endianness,
    dynstr: &mut Vec<u8>,
    dynamic: &mut OwnedDynamic,
    needed: &mut Vec<Vec<u8>>,
) {

        OwnedDynamic::B32(b) => retain_needed_::<u32>(dynstr, b, needed),
        OwnedDynamic::B64(b) => retain_needed_::<u64>(dynstr, b, needed),

        OwnedDynamic::B32(b) => retain_needed_::<u32>(id, dynstr, b, needed),
        OwnedDynamic::B64(b) => retain_needed_::<u64>(id, dynstr, b, needed),

fn retain_needed_<F: Flags>(dynstr: &mut Vec<u8>, dynamic: &mut Vec<F::Dyn>, needed: &[Vec<u8>]) {

fn retain_needed_<F: Flags>(
    id: Endianness,
    dynstr: &mut Vec<u8>,
    dynamic: &mut Vec<F::Dyn>,
    needed: &[Vec<u8>],
) {

        if F::tag(*d) == F::dt_needed() {
            let off = F::d_un(*d);

        if F::tag(id, *d) == F::dt_needed() {
            let off = F::d_un(id, *d);

        if F::tag(d) == F::tag_nul() {

        if F::tag(id, d) == F::tag_nul() {

        } else if F::tag(d) != F::dt_needed() {

        } else if F::tag(id, d) != F::dt_needed() {

                F::set_d_un(&mut d, *off);

                F::set_d_un(id, &mut d, *off);

                F::set_d_un(&mut d, dynstr.len() + extra_dynstr.len());

                F::set_d_un(id, &mut d, dynstr.len() + extra_dynstr.len());

            new_dynamic.push(F::dyn_(F::dt_needed(), *off))

            new_dynamic.push(F::dyn_(id, F::dt_needed(), *off))

            new_dynamic.push(F::dyn_(F::dt_needed(), dynstr.len() + extra_dynstr.len()));

            new_dynamic.push(F::dyn_(
                id,
                F::dt_needed(),
                dynstr.len() + extra_dynstr.len(),
            ));

    new_dynamic.push(F::dyn_(F::tag_nul(), 0));

    new_dynamic.push(F::dyn_(id, F::tag_nul(), 0));

        new_dynamic.push(F::dyn_(F::tag_nul(), 0));

        new_dynamic.push(F::dyn_(id, F::tag_nul(), 0));

fn set_runpath(dynstr: &mut Vec<u8>, dynamic: &mut OwnedDynamic, rpath: &[u8]) {

fn set_runpath(id: Endianness, dynstr: &mut Vec<u8>, dynamic: &mut OwnedDynamic, rpath: &[u8]) {

        OwnedDynamic::B32(b) => set_runpath_::<u32>(dynstr, b, rpath),
        OwnedDynamic::B64(b) => set_runpath_::<u64>(dynstr, b, rpath),

        OwnedDynamic::B32(b) => set_runpath_::<u32>(id, dynstr, b, rpath),
        OwnedDynamic::B64(b) => set_runpath_::<u64>(id, dynstr, b, rpath),

                    if d.tag == <u64 as Flags>::dt_runpath() {
                        rpath = Some(self.dynstr.name(d.d_un as usize)?);

                    if EndianT::endian(d.tag, self.data) == <u64 as Flags>::dt_runpath() {
                        rpath = Some(
                            self.dynstr
                                .name(EndianT::endian(d.d_un, self.data) as usize)?,
                        );

                    if d.tag == <u32 as Flags>::dt_runpath() {
                        rpath = Some(self.dynstr.name(d.d_un as usize)?);

                    if EndianT::endian(d.tag, self.data) == <u32 as Flags>::dt_runpath() {
                        rpath = Some(
                            self.dynstr
                                .name(EndianT::endian(d.d_un, self.data) as usize)?,
                        );

                if d.tag == <u64 as Flags>::dt_needed() {
                    Some(self.dynstr.name(d.d_un as usize))

                if EndianT::endian(d.tag, self.data) == <u64 as Flags>::dt_needed() {
                    Some(
                        self.dynstr
                            .name(EndianT::endian(d.d_un, self.data) as usize),
                    )

                if d.tag == <u32 as Flags>::dt_needed() {
                    Some(self.dynstr.name(d.d_un as usize))

                if EndianT::endian(d.tag, self.data) == <u32 as Flags>::dt_needed() {
                    Some(
                        self.dynstr
                            .name(EndianT::endian(d.d_un, self.data) as usize),
                    )

    pub fn interpreter(&self) -> Result<&'a CStr, Error> {
        Ok(CStr::from_bytes_until_nul(self.interp).unwrap())

    pub fn interpreter(&self) -> Result<Option<&'a CStr>, Error> {
        Ok(self.interp.map(|x| CStr::from_bytes_until_nul(x).unwrap()))

impl<'a> Iterator for Dynamic<'a> {
    type Item = Elf64Dyn;
    fn next(&mut self) -> Option<Self::Item> {
        match self {
            Dynamic::B32(x) => {
                if x.is_empty() {
                    None
                } else {
                    let (a, b) = x.split_at(1);
                    *x = b;
                    let a = a[0];
                    Some(Elf64Dyn {
                        tag: DynTag64(a.tag.0 as u64),
                        d_un: a.d_un as u64,
                    })
                }
            }
            Dynamic::B64(x) => {
                if x.is_empty() {
                    None
                } else {
                    let (a, b) = x.split_at(1);
                    *x = b;
                    Some(a[0])
                }
            }
        }
    }
}

    fn dyn_(tag: Self::DynTag, d_un: usize) -> Self::Dyn;

    fn dyn_(id: Endianness, tag: Self::DynTag, d_un: usize) -> Self::Dyn;

    fn d_un(_: Self::Dyn) -> usize;
    fn set_d_un(_: &mut Self::Dyn, _: usize);
    fn tag(_: Self::Dyn) -> Self::DynTag;

    fn d_un(id: Endianness, _: Self::Dyn) -> usize;
    fn set_d_un(id: Endianness, _: &mut Self::Dyn, _: usize);
    fn tag(id: Endianness, _: Self::Dyn) -> Self::DynTag;

    }
    fn dt_strsz() -> Self::DynTag {
        Self::DynTag::from(0x0a)

    fn dt_strtab() -> Self::DynTag {
        Self::DynTag::from(0x5)
    }

        Self::DynTag::from(29)

        Self::DynTag::from(0x1d)

impl EndianT for DynTag32 {
    fn endian(e: Endian<Self>, id: Endianness) -> Self {
        DynTag32(EndianT::endian(Endian(e.0 .0), id))
    }
}

    }
}
impl EndianT for DynTag64 {
    fn endian(e: Endian<Self>, id: Endianness) -> Self {
        DynTag64(EndianT::endian(Endian(e.0 .0), id))

    fn dyn_(tag: Self::DynTag, d_un: usize) -> Self::Dyn {

    fn dyn_(id: Endianness, tag: Self::DynTag, d_un: usize) -> Self::Dyn {

            tag,
            d_un: d_un as u32,

            tag: <Endian<DynTag32>>::from(id, tag),
            d_un: <Endian<u32>>::from(id, d_un as u32),

    fn set_d_un(x: &mut Self::Dyn, val: usize) {
        x.d_un = val as u32

    fn set_d_un(id: Endianness, x: &mut Self::Dyn, val: usize) {
        x.d_un = <Endian<u32>>::from(id, val as u32)

    fn d_un(x: Self::Dyn) -> usize {
        x.d_un as usize

    fn d_un(id: Endianness, x: Self::Dyn) -> usize {
        EndianT::endian(x.d_un, id) as usize

    fn tag(x: Self::Dyn) -> Self::DynTag {
        x.tag

    fn tag(id: Endianness, x: Self::Dyn) -> Self::DynTag {
        EndianT::endian(x.tag, id)

    fn dyn_(tag: Self::DynTag, d_un: usize) -> Self::Dyn {

    fn dyn_(e: Endianness, tag: Self::DynTag, d_un: usize) -> Self::Dyn {

            tag,
            d_un: d_un as u64,

            tag: <Endian<DynTag64>>::from(e, tag),
            d_un: <Endian<u64>>::from(e, d_un as u64),

    fn set_d_un(x: &mut Self::Dyn, val: usize) {
        x.d_un = val as u64

    fn set_d_un(id: Endianness, x: &mut Self::Dyn, val: usize) {
        x.d_un = <Endian<u64>>::from(id, val as u64)

    fn d_un(x: Self::Dyn) -> usize {
        x.d_un as usize

    fn d_un(id: Endianness, x: Self::Dyn) -> usize {
        EndianT::endian(x.d_un, id) as usize

    fn tag(x: Self::Dyn) -> Self::DynTag {
        x.tag

    fn tag(id: Endianness, x: Self::Dyn) -> Self::DynTag {
        EndianT::endian(x.tag, id)

    tag: DynTag32,
    d_un: u32,

    tag: Endian<DynTag32>,
    d_un: Endian<u32>,

    tag: DynTag64,
    d_un: u64,

    tag: Endian<DynTag64>,
    d_un: Endian<u64>,

    fn set_shoff(&mut self, id: Endianness, off: usize) {

    pub fn set_phnum(&mut self, id: Endianness, off: u16) {
        match self {
            HeaderMut_::B32(h) => h.phnum = <Endian<u16>>::from(id, off),
            HeaderMut_::B64(h) => h.phnum = <Endian<u16>>::from(id, off),
        }
    }
    pub fn phnum(&self, id: Endianness) -> u16 {
        match self {
            HeaderMut_::B32(h) => EndianT::endian(h.phnum, id),
            HeaderMut_::B64(h) => EndianT::endian(h.phnum, id),
        }
    }
    pub fn phentsize(&self, id: Endianness) -> u16 {

            HeaderMut_::B32(h) => h.shoff = <Endian<u32>>::from(id, off as u32),
            HeaderMut_::B64(h) => h.shoff = <Endian<u64>>::from(id, off as u64),

            HeaderMut_::B32(h) => EndianT::endian(h.phentsize, id),
            HeaderMut_::B64(h) => EndianT::endian(h.phentsize, id),

    fn shoff(&self, id: Endianness) -> u64 {

    pub fn shoff(&self, id: Endianness) -> u64 {

unsafe fn dynamic_from_raw<'a>(class: Bits, ptr: *const u8, size: usize) -> Dynamic<'a> {
    match class {
        Bits::B32 => {
            assert_eq!((ptr as usize) % std::mem::align_of::<Elf32Dyn>(), 0);
            Dynamic::B32(unsafe { std::slice::from_raw_parts(
                ptr as *const Elf32Dyn,
                size / std::mem::size_of::<Elf32Dyn>(),
            ) })
        }
        Bits::B64 => {
            assert_eq!((ptr as usize) % std::mem::align_of::<Elf64Dyn>(), 0);
            Dynamic::B64(unsafe {std::slice::from_raw_parts(
                ptr as *const Elf64Dyn,
                size / std::mem::size_of::<Elf64Dyn>(),
            )})
        }
        _ => panic!(),
    }
}

tempfile = "3.19.1"