sam3x8e-pac 0.1.6-dev

#[doc = "Peripheral AB Select Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Absr(pub u32);
impl Absr {
    #[doc = "Peripheral A Select."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Peripheral A Select."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Absr {
    #[inline(always)]
    fn default() -> Absr {
        Absr(0)
    }
}
impl core::fmt::Debug for Absr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Absr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Absr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Absr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Additional Interrupt Modes Disables Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Aimdr(pub u32);
impl Aimdr {
    #[doc = "Additional Interrupt Modes Disable."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Additional Interrupt Modes Disable."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Aimdr {
    #[inline(always)]
    fn default() -> Aimdr {
        Aimdr(0)
    }
}
impl core::fmt::Debug for Aimdr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Aimdr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Aimdr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Aimdr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Additional Interrupt Modes Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Aimer(pub u32);
impl Aimer {
    #[doc = "Additional Interrupt Modes Enable."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Additional Interrupt Modes Enable."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Aimer {
    #[inline(always)]
    fn default() -> Aimer {
        Aimer(0)
    }
}
impl core::fmt::Debug for Aimer {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Aimer")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Aimer {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Aimer {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Additional Interrupt Modes Mask Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Aimmr(pub u32);
impl Aimmr {
    #[doc = "Peripheral CD Status."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Peripheral CD Status."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Aimmr {
    #[inline(always)]
    fn default() -> Aimmr {
        Aimmr(0)
    }
}
impl core::fmt::Debug for Aimmr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Aimmr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Aimmr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Aimmr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Clear Output Data Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Codr(pub u32);
impl Codr {
    #[doc = "Clear Output Data"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Clear Output Data"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Codr {
    #[inline(always)]
    fn default() -> Codr {
        Codr(0)
    }
}
impl core::fmt::Debug for Codr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Codr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Codr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Codr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Debouncing Input Filter Select Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Difsr(pub u32);
impl Difsr {
    #[doc = "Debouncing Filtering Select."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Debouncing Filtering Select."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Difsr {
    #[inline(always)]
    fn default() -> Difsr {
        Difsr(0)
    }
}
impl core::fmt::Debug for Difsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Difsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Difsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Difsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Edge/Level Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Elsr(pub u32);
impl Elsr {
    #[doc = "Edge/Level Interrupt source selection."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Edge/Level Interrupt source selection."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Elsr {
    #[inline(always)]
    fn default() -> Elsr {
        Elsr(0)
    }
}
impl core::fmt::Debug for Elsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Elsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Elsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Elsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Edge Select Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Esr(pub u32);
impl Esr {
    #[doc = "Edge Interrupt Selection."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Edge Interrupt Selection."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Esr {
    #[inline(always)]
    fn default() -> Esr {
        Esr(0)
    }
}
impl core::fmt::Debug for Esr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Esr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Esr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Esr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Falling Edge/Low Level Select Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fellsr(pub u32);
impl Fellsr {
    #[doc = "Falling Edge/Low Level Interrupt Selection."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Falling Edge/Low Level Interrupt Selection."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Fellsr {
    #[inline(always)]
    fn default() -> Fellsr {
        Fellsr(0)
    }
}
impl core::fmt::Debug for Fellsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Fellsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Fellsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Fellsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Fall/Rise - Low/High Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Frlhsr(pub u32);
impl Frlhsr {
    #[doc = "Edge /Level Interrupt Source Selection."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Edge /Level Interrupt Source Selection."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Frlhsr {
    #[inline(always)]
    fn default() -> Frlhsr {
        Frlhsr(0)
    }
}
impl core::fmt::Debug for Frlhsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Frlhsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Frlhsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Frlhsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Interrupt Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Idr(pub u32);
impl Idr {
    #[doc = "Input Change Interrupt Disable"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Input Change Interrupt Disable"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Idr {
    #[inline(always)]
    fn default() -> Idr {
        Idr(0)
    }
}
impl core::fmt::Debug for Idr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Idr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Idr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Idr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Interrupt Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ier(pub u32);
impl Ier {
    #[doc = "Input Change Interrupt Enable"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Input Change Interrupt Enable"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Ier {
    #[inline(always)]
    fn default() -> Ier {
        Ier(0)
    }
}
impl core::fmt::Debug for Ier {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Ier")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ier {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Ier {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Glitch or Debouncing Input Filter Clock Selection Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ifdgsr(pub u32);
impl Ifdgsr {
    #[doc = "Glitch or Debouncing Filter Selection Status"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Glitch or Debouncing Filter Selection Status"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Ifdgsr {
    #[inline(always)]
    fn default() -> Ifdgsr {
        Ifdgsr(0)
    }
}
impl core::fmt::Debug for Ifdgsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Ifdgsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ifdgsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Ifdgsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Glitch Input Filter Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ifdr(pub u32);
impl Ifdr {
    #[doc = "Input Filter Disable"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Input Filter Disable"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Ifdr {
    #[inline(always)]
    fn default() -> Ifdr {
        Ifdr(0)
    }
}
impl core::fmt::Debug for Ifdr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Ifdr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ifdr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Ifdr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Glitch Input Filter Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ifer(pub u32);
impl Ifer {
    #[doc = "Input Filter Enable"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Input Filter Enable"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Ifer {
    #[inline(always)]
    fn default() -> Ifer {
        Ifer(0)
    }
}
impl core::fmt::Debug for Ifer {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Ifer")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ifer {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Ifer {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Glitch Input Filter Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ifsr(pub u32);
impl Ifsr {
    #[doc = "Input Filer Status"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Input Filer Status"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Ifsr {
    #[inline(always)]
    fn default() -> Ifsr {
        Ifsr(0)
    }
}
impl core::fmt::Debug for Ifsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Ifsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ifsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Ifsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Interrupt Mask Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Imr(pub u32);
impl Imr {
    #[doc = "Input Change Interrupt Mask"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Input Change Interrupt Mask"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Imr {
    #[inline(always)]
    fn default() -> Imr {
        Imr(0)
    }
}
impl core::fmt::Debug for Imr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Imr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Imr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Imr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Interrupt Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Isr(pub u32);
impl Isr {
    #[doc = "Input Change Interrupt Status"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Input Change Interrupt Status"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Isr {
    #[inline(always)]
    fn default() -> Isr {
        Isr(0)
    }
}
impl core::fmt::Debug for Isr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Isr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Isr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Isr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Lock Status"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Locksr(pub u32);
impl Locksr {
    #[doc = "Lock Status."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Lock Status."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Locksr {
    #[inline(always)]
    fn default() -> Locksr {
        Locksr(0)
    }
}
impl core::fmt::Debug for Locksr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Locksr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Locksr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Locksr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Level Select Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Lsr(pub u32);
impl Lsr {
    #[doc = "Level Interrupt Selection."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Level Interrupt Selection."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Lsr {
    #[inline(always)]
    fn default() -> Lsr {
        Lsr(0)
    }
}
impl core::fmt::Debug for Lsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Lsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Lsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Lsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Multi-driver Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mddr(pub u32);
impl Mddr {
    #[doc = "Multi Drive Disable."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Multi Drive Disable."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Mddr {
    #[inline(always)]
    fn default() -> Mddr {
        Mddr(0)
    }
}
impl core::fmt::Debug for Mddr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Mddr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mddr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Mddr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Multi-driver Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mder(pub u32);
impl Mder {
    #[doc = "Multi Drive Enable."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Multi Drive Enable."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Mder {
    #[inline(always)]
    fn default() -> Mder {
        Mder(0)
    }
}
impl core::fmt::Debug for Mder {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Mder")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mder {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Mder {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Multi-driver Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mdsr(pub u32);
impl Mdsr {
    #[doc = "Multi Drive Status."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Multi Drive Status."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Mdsr {
    #[inline(always)]
    fn default() -> Mdsr {
        Mdsr(0)
    }
}
impl core::fmt::Debug for Mdsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Mdsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mdsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Mdsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Output Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Odr(pub u32);
impl Odr {
    #[doc = "Output Disable"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Output Disable"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Odr {
    #[inline(always)]
    fn default() -> Odr {
        Odr(0)
    }
}
impl core::fmt::Debug for Odr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Odr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Odr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Odr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Output Data Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Odsr(pub u32);
impl Odsr {
    #[doc = "Output Data Status"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Output Data Status"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Odsr {
    #[inline(always)]
    fn default() -> Odsr {
        Odsr(0)
    }
}
impl core::fmt::Debug for Odsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Odsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Odsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Odsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Output Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Oer(pub u32);
impl Oer {
    #[doc = "Output Enable"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Output Enable"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Oer {
    #[inline(always)]
    fn default() -> Oer {
        Oer(0)
    }
}
impl core::fmt::Debug for Oer {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Oer")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Oer {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Oer {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Output Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Osr(pub u32);
impl Osr {
    #[doc = "Output Status"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Output Status"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Osr {
    #[inline(always)]
    fn default() -> Osr {
        Osr(0)
    }
}
impl core::fmt::Debug for Osr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Osr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Osr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Osr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Output Write Disable"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Owdr(pub u32);
impl Owdr {
    #[doc = "Output Write Disable."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Output Write Disable."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Owdr {
    #[inline(always)]
    fn default() -> Owdr {
        Owdr(0)
    }
}
impl core::fmt::Debug for Owdr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Owdr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Owdr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Owdr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Output Write Enable"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ower(pub u32);
impl Ower {
    #[doc = "Output Write Enable."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Output Write Enable."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Ower {
    #[inline(always)]
    fn default() -> Ower {
        Ower(0)
    }
}
impl core::fmt::Debug for Ower {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Ower")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ower {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Ower {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Output Write Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Owsr(pub u32);
impl Owsr {
    #[doc = "Output Write Status."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Output Write Status."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Owsr {
    #[inline(always)]
    fn default() -> Owsr {
        Owsr(0)
    }
}
impl core::fmt::Debug for Owsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Owsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Owsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Owsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "PIO Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Pdr(pub u32);
impl Pdr {
    #[doc = "PIO Disable"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "PIO Disable"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Pdr {
    #[inline(always)]
    fn default() -> Pdr {
        Pdr(0)
    }
}
impl core::fmt::Debug for Pdr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Pdr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Pdr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Pdr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Pin Data Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Pdsr(pub u32);
impl Pdsr {
    #[doc = "Output Data Status"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Output Data Status"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Pdsr {
    #[inline(always)]
    fn default() -> Pdsr {
        Pdsr(0)
    }
}
impl core::fmt::Debug for Pdsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Pdsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Pdsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Pdsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "PIO Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Per(pub u32);
impl Per {
    #[doc = "PIO Enable"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "PIO Enable"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Per {
    #[inline(always)]
    fn default() -> Per {
        Per(0)
    }
}
impl core::fmt::Debug for Per {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Per")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Per {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Per {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "PIO Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Psr(pub u32);
impl Psr {
    #[doc = "PIO Status"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "PIO Status"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Psr {
    #[inline(always)]
    fn default() -> Psr {
        Psr(0)
    }
}
impl core::fmt::Debug for Psr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Psr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Psr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Psr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Pull-up Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Pudr(pub u32);
impl Pudr {
    #[doc = "Pull Up Disable."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Pull Up Disable."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Pudr {
    #[inline(always)]
    fn default() -> Pudr {
        Pudr(0)
    }
}
impl core::fmt::Debug for Pudr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Pudr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Pudr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Pudr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Pull-up Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Puer(pub u32);
impl Puer {
    #[doc = "Pull Up Enable."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Pull Up Enable."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Puer {
    #[inline(always)]
    fn default() -> Puer {
        Puer(0)
    }
}
impl core::fmt::Debug for Puer {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Puer")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Puer {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Puer {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Pad Pull-up Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Pusr(pub u32);
impl Pusr {
    #[doc = "Pull Up Status."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Pull Up Status."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Pusr {
    #[inline(always)]
    fn default() -> Pusr {
        Pusr(0)
    }
}
impl core::fmt::Debug for Pusr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Pusr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Pusr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Pusr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Rising Edge/ High Level Select Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rehlsr(pub u32);
impl Rehlsr {
    #[doc = "Rising Edge /High Level Interrupt Selection."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Rising Edge /High Level Interrupt Selection."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Rehlsr {
    #[inline(always)]
    fn default() -> Rehlsr {
        Rehlsr(0)
    }
}
impl core::fmt::Debug for Rehlsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Rehlsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rehlsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Rehlsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Slow Clock Divider Debouncing Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Scdr(pub u32);
impl Scdr {
    #[doc = "Slow Clock Divider Selection for Debouncing"]
    #[must_use]
    #[inline(always)]
    pub const fn div(&self) -> u16 {
        let val = (self.0 >> 0usize) & 0x3fff;
        val as u16
    }
    #[doc = "Slow Clock Divider Selection for Debouncing"]
    #[inline(always)]
    pub const fn set_div(&mut self, val: u16) {
        self.0 = (self.0 & !(0x3fff << 0usize)) | (((val as u32) & 0x3fff) << 0usize);
    }
}
impl Default for Scdr {
    #[inline(always)]
    fn default() -> Scdr {
        Scdr(0)
    }
}
impl core::fmt::Debug for Scdr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Scdr").field("div", &self.div()).finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Scdr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(f, "Scdr {{ div: {=u16:?} }}", self.div())
    }
}
#[doc = "System Clock Glitch Input Filter Select Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Scifsr(pub u32);
impl Scifsr {
    #[doc = "System Clock Glitch Filtering Select."]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "System Clock Glitch Filtering Select."]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Scifsr {
    #[inline(always)]
    fn default() -> Scifsr {
        Scifsr(0)
    }
}
impl core::fmt::Debug for Scifsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Scifsr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Scifsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Scifsr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Set Output Data Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sodr(pub u32);
impl Sodr {
    #[doc = "Set Output Data"]
    #[must_use]
    #[inline(always)]
    pub const fn pin(&self, n: usize) -> bool {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        let val = (self.0 >> offs) & 0x01;
        val != 0
    }
    #[doc = "Set Output Data"]
    #[inline(always)]
    pub const fn set_pin(&mut self, n: usize, val: bool) {
        assert!(n < 32usize);
        let offs = 0usize + n * 1usize;
        self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
    }
}
impl Default for Sodr {
    #[inline(always)]
    fn default() -> Sodr {
        Sodr(0)
    }
}
impl core::fmt::Debug for Sodr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Sodr")
            .field("pin[0]", &self.pin(0usize))
            .field("pin[1]", &self.pin(1usize))
            .field("pin[2]", &self.pin(2usize))
            .field("pin[3]", &self.pin(3usize))
            .field("pin[4]", &self.pin(4usize))
            .field("pin[5]", &self.pin(5usize))
            .field("pin[6]", &self.pin(6usize))
            .field("pin[7]", &self.pin(7usize))
            .field("pin[8]", &self.pin(8usize))
            .field("pin[9]", &self.pin(9usize))
            .field("pin[10]", &self.pin(10usize))
            .field("pin[11]", &self.pin(11usize))
            .field("pin[12]", &self.pin(12usize))
            .field("pin[13]", &self.pin(13usize))
            .field("pin[14]", &self.pin(14usize))
            .field("pin[15]", &self.pin(15usize))
            .field("pin[16]", &self.pin(16usize))
            .field("pin[17]", &self.pin(17usize))
            .field("pin[18]", &self.pin(18usize))
            .field("pin[19]", &self.pin(19usize))
            .field("pin[20]", &self.pin(20usize))
            .field("pin[21]", &self.pin(21usize))
            .field("pin[22]", &self.pin(22usize))
            .field("pin[23]", &self.pin(23usize))
            .field("pin[24]", &self.pin(24usize))
            .field("pin[25]", &self.pin(25usize))
            .field("pin[26]", &self.pin(26usize))
            .field("pin[27]", &self.pin(27usize))
            .field("pin[28]", &self.pin(28usize))
            .field("pin[29]", &self.pin(29usize))
            .field("pin[30]", &self.pin(30usize))
            .field("pin[31]", &self.pin(31usize))
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sodr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Sodr {{ pin[0]: {=bool:?}, pin[1]: {=bool:?}, pin[2]: {=bool:?}, pin[3]: {=bool:?}, pin[4]: {=bool:?}, pin[5]: {=bool:?}, pin[6]: {=bool:?}, pin[7]: {=bool:?}, pin[8]: {=bool:?}, pin[9]: {=bool:?}, pin[10]: {=bool:?}, pin[11]: {=bool:?}, pin[12]: {=bool:?}, pin[13]: {=bool:?}, pin[14]: {=bool:?}, pin[15]: {=bool:?}, pin[16]: {=bool:?}, pin[17]: {=bool:?}, pin[18]: {=bool:?}, pin[19]: {=bool:?}, pin[20]: {=bool:?}, pin[21]: {=bool:?}, pin[22]: {=bool:?}, pin[23]: {=bool:?}, pin[24]: {=bool:?}, pin[25]: {=bool:?}, pin[26]: {=bool:?}, pin[27]: {=bool:?}, pin[28]: {=bool:?}, pin[29]: {=bool:?}, pin[30]: {=bool:?}, pin[31]: {=bool:?} }}",
            self.pin(0usize),
            self.pin(1usize),
            self.pin(2usize),
            self.pin(3usize),
            self.pin(4usize),
            self.pin(5usize),
            self.pin(6usize),
            self.pin(7usize),
            self.pin(8usize),
            self.pin(9usize),
            self.pin(10usize),
            self.pin(11usize),
            self.pin(12usize),
            self.pin(13usize),
            self.pin(14usize),
            self.pin(15usize),
            self.pin(16usize),
            self.pin(17usize),
            self.pin(18usize),
            self.pin(19usize),
            self.pin(20usize),
            self.pin(21usize),
            self.pin(22usize),
            self.pin(23usize),
            self.pin(24usize),
            self.pin(25usize),
            self.pin(26usize),
            self.pin(27usize),
            self.pin(28usize),
            self.pin(29usize),
            self.pin(30usize),
            self.pin(31usize)
        )
    }
}
#[doc = "Write Protect Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpmr(pub u32);
impl Wpmr {
    #[doc = "Write Protect Enable"]
    #[must_use]
    #[inline(always)]
    pub const fn wpen(&self) -> bool {
        let val = (self.0 >> 0usize) & 0x01;
        val != 0
    }
    #[doc = "Write Protect Enable"]
    #[inline(always)]
    pub const fn set_wpen(&mut self, val: bool) {
        self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
    }
    #[doc = "Write Protect KEY"]
    #[must_use]
    #[inline(always)]
    pub const fn wpkey(&self) -> u32 {
        let val = (self.0 >> 8usize) & 0x00ff_ffff;
        val as u32
    }
    #[doc = "Write Protect KEY"]
    #[inline(always)]
    pub const fn set_wpkey(&mut self, val: u32) {
        self.0 = (self.0 & !(0x00ff_ffff << 8usize)) | (((val as u32) & 0x00ff_ffff) << 8usize);
    }
}
impl Default for Wpmr {
    #[inline(always)]
    fn default() -> Wpmr {
        Wpmr(0)
    }
}
impl core::fmt::Debug for Wpmr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Wpmr")
            .field("wpen", &self.wpen())
            .field("wpkey", &self.wpkey())
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wpmr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Wpmr {{ wpen: {=bool:?}, wpkey: {=u32:?} }}",
            self.wpen(),
            self.wpkey()
        )
    }
}
#[doc = "Write Protect Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpsr(pub u32);
impl Wpsr {
    #[doc = "Write Protect Violation Status"]
    #[must_use]
    #[inline(always)]
    pub const fn wpvs(&self) -> bool {
        let val = (self.0 >> 0usize) & 0x01;
        val != 0
    }
    #[doc = "Write Protect Violation Status"]
    #[inline(always)]
    pub const fn set_wpvs(&mut self, val: bool) {
        self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
    }
    #[doc = "Write Protect Violation Source"]
    #[must_use]
    #[inline(always)]
    pub const fn wpvsrc(&self) -> u16 {
        let val = (self.0 >> 8usize) & 0xffff;
        val as u16
    }
    #[doc = "Write Protect Violation Source"]
    #[inline(always)]
    pub const fn set_wpvsrc(&mut self, val: u16) {
        self.0 = (self.0 & !(0xffff << 8usize)) | (((val as u32) & 0xffff) << 8usize);
    }
}
impl Default for Wpsr {
    #[inline(always)]
    fn default() -> Wpsr {
        Wpsr(0)
    }
}
impl core::fmt::Debug for Wpsr {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("Wpsr")
            .field("wpvs", &self.wpvs())
            .field("wpvsrc", &self.wpvsrc())
            .finish()
    }
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wpsr {
    fn format(&self, f: defmt::Formatter) {
        defmt::write!(
            f,
            "Wpsr {{ wpvs: {=bool:?}, wpvsrc: {=u16:?} }}",
            self.wpvs(),
            self.wpvsrc()
        )
    }
}