#[error("No dynamic section")]
    NoDynamicSection,

struct Endianness(u8);

pub struct Endianness(u8);

}
#[allow(dead_code)]
impl ABI {
    const SYSTEM_V: Self = ABI(0);
    const HPUX: Self = ABI(1);
    const NET_BSD: Self = ABI(2);
    const LINUX: Self = ABI(3);
    const GNU_HURD: Self = ABI(4);
    const SOLARIS: Self = ABI(6);
    const AIX: Self = ABI(7);
    const IRIX: Self = ABI(8);
    const FREE_BSD: Self = ABI(9);
    const TRU64: Self = ABI(10);
    const NOVELL_MODESTO: Self = ABI(11);
    const OPEN_BSD: Self = ABI(12);
    const OPEN_VMS: Self = ABI(13);
    const NON_STOP_KERNEL: Self = ABI(14);
    const AROS: Self = ABI(15);
    const FENIX_OS: Self = ABI(16);
    const NUXI_CLOUD_ABI: Self = ABI(17);
    const OPEN_VOS: Self = ABI(18);

struct Id {

pub struct Id {

            Sht(u32::from_le(e.0 .0))

            Sht(u32::from_le(e.0.0))

            Sht(u32::from_be(e.0 .0))

            Sht(u32::from_be(e.0.0))

            Pht(u32::from_le(e.0 .0))

            Pht(u32::from_le(e.0.0))

            Pht(u32::from_be(e.0 .0))

            Pht(u32::from_be(e.0.0))

        // For now we set them to be equal.
        self.set_paddr(h, u);

    pub fn set_paddr(&mut self, h: Endianness, u: usize) {
        match self {
            ProgramHeaderMut_::B32(s) => s.paddr = <Endian<u32>>::from(h, u as u32),
            ProgramHeaderMut_::B64(s) => s.paddr = <Endian<u64>>::from(h, u as u64),
        }
    }

#[allow(dead_code)]

    const NULL: Self = Pht(0);

    const DYNAMIC: Self = Pht(2);
    const INTERP: Self = Pht(3);
    const NOTE: Self = Pht(4);
    const SHLIB: Self = Pht(5);

    const TLS: Self = Pht(7);
    const LOOS: Self = Pht(0x60000000);
    const HIOS: Self = Pht(0x6fffffff);
    const LOPROC: Self = Pht(0x70000000);
    const HIPROC: Self = Pht(0x7fffffff);

        if e.id().magic == [0x7f, 0x45, 0x4c, 0x46] {

        if e.map.len() >= std::mem::size_of::<Header<u32>>()
            && e.id().magic == [0x7f, 0x45, 0x4c, 0x46]
        {

    fn id(&self) -> &Id {

    pub fn id(&self) -> &Id {

        // The aligment is guaranteed here by design of the
        // ELF file. The size isn't, however.

        // The aligment is guaranteed here by design of the ELF
        // file. The size isn't, however, so we need to check it.

    pub fn parse(&self) -> Result<Parsed, Error> {

    pub fn parse(&self) -> Result<Option<Parsed>, Error> {

        let mut dynamic = Dynamic::B32(&[]);

        let mut dynamic = None;

                dynamic =
                    unsafe { dynamic_from_raw(id.class, self.map.as_ptr().add(offset), size) };

                dynamic = Some(unsafe {
                    dynamic_from_raw(id.class, self.map.as_ptr().add(offset), size)
                });

        }
        if let Some(dynamic) = dynamic {
            Ok(Some(Parsed {
                data: id.data,
                dynstr,
                dynamic,
                interp,
            }))
        } else {
            Ok(None)

    }

        Ok(Parsed {
            data: id.data,
            dynstr,
            dynamic,
            interp,
        })

    pub fn section_bytes(&self, name_: &[u8]) -> Result<Option<&[u8]>, Error> {
        let id = self.id();
        let header = self.header();
        let names = self.names(id.data, &header);
        for i in 0..header.shnum(id.data) {
            let s = self.section(i as usize);
            let name = names.name(s.name(id.data) as usize)?;
            if name.to_bytes() == name_ {
                let offset = s.offset(id.data) as usize;
                let size = s.size(id.data) as usize;
                return Ok(Some(&self.map[offset..offset + size]));
            }
        }
        Ok(None)

    fn update_section_allocate(
        &mut self,
        id: Endianness,
        new: &[u8],
        interp_i: usize,
    ) {

    fn update_section_allocate(&mut self, id: Endianness, new: &[u8], interp_i: usize) {

                (sh.offset(id) as usize, sh.size(id) as usize, p_ as isize)

                (sh.offset(id) as usize,
                 sh.size(id) as usize,
                 sh.type_(id),
                 p_ as isize)

            Sht::NULL,

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

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

            .position(|(_, _, i)| *i == interp_i as isize)

            .position(|(_, _, _, i)| *i == interp_i as isize)

        for (off, len, _) in sections.iter().skip(s + 1) {

        for (off, len, _, _) in sections.iter().skip(s + 1) {

            // Combien de sections doit-on déplacer pour ajouter notre

            // Combien de sections du début du fichier doit-on
            // déplacer à la fin pour ajouter notre nouveau header de

                .filter_map(|(o, _, _)| {

                .filter_map(|(o, _, _, _)| {

                for (n, (o, _, _)) in sections.iter().enumerate() {

                for (n, (o, _, _, _)) in sections.iter().enumerate() {

                let current_len = self.f.metadata().unwrap().len() as usize;

                // Max between the length of the file and the max of
                // the sections' span.
                let current_len =
                    sections.iter().map(|(o, l, t, _)|
                        if *t != Sht::NOBITS {
                            o + l
                        } else {
                            0
                        })
                    .max()
                    .unwrap_or(
                        self.f.metadata().unwrap().len() as usize
                    );

                let rounded_moved =
                    align_next(end_off - init_off, page_size as usize);

                let rounded_moved = align_next(end_off - init_off, page_size as usize);

                    let sec_n = sections[s].2;

                    let sec_n = sections[s].3;

                    sec.set_addr(
                        id,
                        new_offset + rounded_last_vaddr - rounded_len as usize,
                    );

                    sec.set_addr(id, new_offset + rounded_last_vaddr - rounded_len as usize);

                            p.set_vaddr(
                                id,
                                new_offset + rounded_last_vaddr - rounded_len as usize,
                            );

                            p.set_vaddr(id, new_offset + rounded_last_vaddr - rounded_len as usize);

                let current_len = self.f.metadata().unwrap().len() as usize;

                let current_len =
                    sections.iter().map(|(o, l, t, _)| {
                        if *t != Sht::NOBITS {
                            o + l
                        } else {
                            0
                        }
                    })
                    .max()
                    .unwrap_or(
                        self.f.metadata().unwrap().len() as usize
                    );

        p.set_flags(id, flags);

        p.set_flags(id, flags | 6); // must be RW since it's at the end.

            let parsed = self.parse()?;

            let Some(parsed) = self.parse()? else {
                return Err(Error::NoDynamicSection)
            };

            let parsed = self.parse()?;

            let Some(parsed) = self.parse()? else {
                return Err(Error::NoDynamicSection)
            };

        let parsed = self.parse()?;

        let Some(parsed) = self.parse()? else {
            return Err(Error::NoDynamicSection)
        };
        let initial_dynamic_len = match dynamic {
            OwnedDynamic::B32(d) => d.len(),
            OwnedDynamic::B64(d) => d.len(),
        };

        }
        match dynamic {
            OwnedDynamic::B32(d) =>
                while d.len() < initial_dynamic_len {
                    d.push(u32::dyn_(id, u32::tag_nul(), 0));
                }
            OwnedDynamic::B64(d) =>
                while d.len() < initial_dynamic_len {
                    d.push(u64::dyn_(id, u64::tag_nul(), 0));
                }

        let p = self.parse()?;

        let Some(p) = self.parse()? else {
            return Ok(())
        };

        let new_needed = std::mem::replace(&mut self.new_needed, None);

        let new_needed = self.new_needed.take();

            self
                .update_section(b".dynamic", dynamic_owned.as_bytes())

            self.update_section(b".dynamic", dynamic_owned.as_bytes())

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

        } else if F::tag(id, *f) == F::dt_gnuhash() {
            let s = self.find_section::<F>(b".gnu.hash").unwrap().unwrap();
            let sec = self.section(s);
            F::set_d_un(id, f, sec.addr(id) as usize)

/// If the "needed" and/or "runpath" fields in the .dynamic section
/// point to the end of the .dynstr section, we can optimise the
/// .dynstr section by removing them first, and then adding them.
///
/// Otherwise, we will (in other functions) leave these fields where
/// they are, add new ones at the end and ignore the previous values.

    // Put the tags last

    let mut n = 0;
    for (i, x) in dynamic.iter_mut().enumerate() {

    for x in dynamic.iter_mut() {

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

    if F::tag(id, dynamic[dynamic.len() - 2]) == F::tag_nul() {

    // If the dynamic array ends with two DT_NULL, pop one.
    if dynamic.len() >= 2 && F::tag(id, dynamic[dynamic.len() - 2]) == F::tag_nul() {

    dynamic.insert(n + 1, F::dyn_(id, F::dt_runpath(), offset));

    dynamic.insert(0, F::dyn_(id, F::dt_runpath(), offset));

    let initial_dynamic_len = dynamic.len();

    if new_dynamic.len() % 1 == 1 {

    while new_dynamic.len() < initial_dynamic_len {

    fn dt_gnuhash() -> Self::DynTag {
        Self::DynTag::from(0x000000006ffffef5)
    }

        DynTag32(EndianT::endian(Endian(e.0 .0), id))

        DynTag32(EndianT::endian(Endian(e.0.0), id))

        DynTag64(EndianT::endian(Endian(e.0 .0), id))

        DynTag64(EndianT::endian(Endian(e.0.0), id))

    const NOBITS: Self = Sht(8);

    fn phnum(&self, id: Endianness) -> u16 {

    pub fn phnum(&self, id: Endianness) -> u16 {

            Dynamic::B32(unsafe { std::slice::from_raw_parts(
                ptr as *const Elf32Dyn,
                size / std::mem::size_of::<Elf32Dyn>(),
            ) })

            Dynamic::B32(unsafe {
                std::slice::from_raw_parts(
                    ptr as *const Elf32Dyn,
                    size / std::mem::size_of::<Elf32Dyn>(),
                )
            })

            Dynamic::B64(unsafe {std::slice::from_raw_parts(
                ptr as *const Elf64Dyn,
                size / std::mem::size_of::<Elf64Dyn>(),
            )})

            Dynamic::B64(unsafe {
                std::slice::from_raw_parts(
                    ptr as *const Elf64Dyn,
                    size / std::mem::size_of::<Elf64Dyn>(),
                )
            })