#[doc = "Register `PF` reader"]
pub type R = crate::R<PfSpec>;
#[doc = "Register `PF` writer"]
pub type W = crate::W<PfSpec>;
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf0 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf0> for bool {
    #[inline(always)]
    fn from(variant: Wuf0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF0` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf0R = crate::BitReader<Wuf0>;
impl Wuf0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf0 {
        match self.bits {
            false => Wuf0::NoFlag,
            true => Wuf0::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf0::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf0::Flag
    }
}
#[doc = "Field `WUF0` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf0W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf0>;
impl<'a, REG> Wuf0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf0::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf0::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf1 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf1> for bool {
    #[inline(always)]
    fn from(variant: Wuf1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF1` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf1R = crate::BitReader<Wuf1>;
impl Wuf1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf1 {
        match self.bits {
            false => Wuf1::NoFlag,
            true => Wuf1::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf1::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf1::Flag
    }
}
#[doc = "Field `WUF1` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf1W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf1>;
impl<'a, REG> Wuf1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf1::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf1::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf2 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf2> for bool {
    #[inline(always)]
    fn from(variant: Wuf2) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF2` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf2R = crate::BitReader<Wuf2>;
impl Wuf2R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf2 {
        match self.bits {
            false => Wuf2::NoFlag,
            true => Wuf2::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf2::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf2::Flag
    }
}
#[doc = "Field `WUF2` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf2W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf2>;
impl<'a, REG> Wuf2W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf2::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf2::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf3 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf3> for bool {
    #[inline(always)]
    fn from(variant: Wuf3) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF3` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf3R = crate::BitReader<Wuf3>;
impl Wuf3R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf3 {
        match self.bits {
            false => Wuf3::NoFlag,
            true => Wuf3::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf3::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf3::Flag
    }
}
#[doc = "Field `WUF3` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf3W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf3>;
impl<'a, REG> Wuf3W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf3::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf3::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf4 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf4> for bool {
    #[inline(always)]
    fn from(variant: Wuf4) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF4` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf4R = crate::BitReader<Wuf4>;
impl Wuf4R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf4 {
        match self.bits {
            false => Wuf4::NoFlag,
            true => Wuf4::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf4::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf4::Flag
    }
}
#[doc = "Field `WUF4` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf4W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf4>;
impl<'a, REG> Wuf4W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf4::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf4::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf5 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf5> for bool {
    #[inline(always)]
    fn from(variant: Wuf5) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF5` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf5R = crate::BitReader<Wuf5>;
impl Wuf5R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf5 {
        match self.bits {
            false => Wuf5::NoFlag,
            true => Wuf5::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf5::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf5::Flag
    }
}
#[doc = "Field `WUF5` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf5W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf5>;
impl<'a, REG> Wuf5W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf5::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf5::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf6 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf6> for bool {
    #[inline(always)]
    fn from(variant: Wuf6) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF6` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf6R = crate::BitReader<Wuf6>;
impl Wuf6R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf6 {
        match self.bits {
            false => Wuf6::NoFlag,
            true => Wuf6::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf6::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf6::Flag
    }
}
#[doc = "Field `WUF6` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf6W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf6>;
impl<'a, REG> Wuf6W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf6::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf6::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf7 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf7> for bool {
    #[inline(always)]
    fn from(variant: Wuf7) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF7` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf7R = crate::BitReader<Wuf7>;
impl Wuf7R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf7 {
        match self.bits {
            false => Wuf7::NoFlag,
            true => Wuf7::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf7::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf7::Flag
    }
}
#[doc = "Field `WUF7` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf7W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf7>;
impl<'a, REG> Wuf7W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf7::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf7::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf8 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf8> for bool {
    #[inline(always)]
    fn from(variant: Wuf8) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF8` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf8R = crate::BitReader<Wuf8>;
impl Wuf8R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf8 {
        match self.bits {
            false => Wuf8::NoFlag,
            true => Wuf8::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf8::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf8::Flag
    }
}
#[doc = "Field `WUF8` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf8W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf8>;
impl<'a, REG> Wuf8W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf8::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf8::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf9 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf9> for bool {
    #[inline(always)]
    fn from(variant: Wuf9) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF9` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf9R = crate::BitReader<Wuf9>;
impl Wuf9R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf9 {
        match self.bits {
            false => Wuf9::NoFlag,
            true => Wuf9::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf9::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf9::Flag
    }
}
#[doc = "Field `WUF9` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf9W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf9>;
impl<'a, REG> Wuf9W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf9::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf9::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf10 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf10> for bool {
    #[inline(always)]
    fn from(variant: Wuf10) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF10` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf10R = crate::BitReader<Wuf10>;
impl Wuf10R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf10 {
        match self.bits {
            false => Wuf10::NoFlag,
            true => Wuf10::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf10::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf10::Flag
    }
}
#[doc = "Field `WUF10` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf10W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf10>;
impl<'a, REG> Wuf10W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf10::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf10::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf11 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf11> for bool {
    #[inline(always)]
    fn from(variant: Wuf11) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF11` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf11R = crate::BitReader<Wuf11>;
impl Wuf11R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf11 {
        match self.bits {
            false => Wuf11::NoFlag,
            true => Wuf11::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf11::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf11::Flag
    }
}
#[doc = "Field `WUF11` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf11W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf11>;
impl<'a, REG> Wuf11W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf11::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf11::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf12 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf12> for bool {
    #[inline(always)]
    fn from(variant: Wuf12) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF12` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf12R = crate::BitReader<Wuf12>;
impl Wuf12R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf12 {
        match self.bits {
            false => Wuf12::NoFlag,
            true => Wuf12::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf12::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf12::Flag
    }
}
#[doc = "Field `WUF12` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf12W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf12>;
impl<'a, REG> Wuf12W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf12::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf12::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf13 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf13> for bool {
    #[inline(always)]
    fn from(variant: Wuf13) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF13` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf13R = crate::BitReader<Wuf13>;
impl Wuf13R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf13 {
        match self.bits {
            false => Wuf13::NoFlag,
            true => Wuf13::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf13::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf13::Flag
    }
}
#[doc = "Field `WUF13` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf13W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf13>;
impl<'a, REG> Wuf13W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf13::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf13::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf14 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf14> for bool {
    #[inline(always)]
    fn from(variant: Wuf14) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF14` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf14R = crate::BitReader<Wuf14>;
impl Wuf14R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf14 {
        match self.bits {
            false => Wuf14::NoFlag,
            true => Wuf14::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf14::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf14::Flag
    }
}
#[doc = "Field `WUF14` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf14W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf14>;
impl<'a, REG> Wuf14W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf14::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf14::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf15 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf15> for bool {
    #[inline(always)]
    fn from(variant: Wuf15) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF15` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf15R = crate::BitReader<Wuf15>;
impl Wuf15R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf15 {
        match self.bits {
            false => Wuf15::NoFlag,
            true => Wuf15::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf15::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf15::Flag
    }
}
#[doc = "Field `WUF15` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf15W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf15>;
impl<'a, REG> Wuf15W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf15::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf15::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf16 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf16> for bool {
    #[inline(always)]
    fn from(variant: Wuf16) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF16` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf16R = crate::BitReader<Wuf16>;
impl Wuf16R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf16 {
        match self.bits {
            false => Wuf16::NoFlag,
            true => Wuf16::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf16::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf16::Flag
    }
}
#[doc = "Field `WUF16` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf16W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf16>;
impl<'a, REG> Wuf16W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf16::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf16::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf17 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf17> for bool {
    #[inline(always)]
    fn from(variant: Wuf17) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF17` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf17R = crate::BitReader<Wuf17>;
impl Wuf17R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf17 {
        match self.bits {
            false => Wuf17::NoFlag,
            true => Wuf17::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf17::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf17::Flag
    }
}
#[doc = "Field `WUF17` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf17W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf17>;
impl<'a, REG> Wuf17W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf17::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf17::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf18 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf18> for bool {
    #[inline(always)]
    fn from(variant: Wuf18) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF18` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf18R = crate::BitReader<Wuf18>;
impl Wuf18R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf18 {
        match self.bits {
            false => Wuf18::NoFlag,
            true => Wuf18::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf18::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf18::Flag
    }
}
#[doc = "Field `WUF18` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf18W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf18>;
impl<'a, REG> Wuf18W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf18::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf18::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf19 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf19> for bool {
    #[inline(always)]
    fn from(variant: Wuf19) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF19` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf19R = crate::BitReader<Wuf19>;
impl Wuf19R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf19 {
        match self.bits {
            false => Wuf19::NoFlag,
            true => Wuf19::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf19::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf19::Flag
    }
}
#[doc = "Field `WUF19` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf19W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf19>;
impl<'a, REG> Wuf19W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf19::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf19::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf20 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf20> for bool {
    #[inline(always)]
    fn from(variant: Wuf20) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF20` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf20R = crate::BitReader<Wuf20>;
impl Wuf20R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf20 {
        match self.bits {
            false => Wuf20::NoFlag,
            true => Wuf20::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf20::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf20::Flag
    }
}
#[doc = "Field `WUF20` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf20W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf20>;
impl<'a, REG> Wuf20W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf20::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf20::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf21 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf21> for bool {
    #[inline(always)]
    fn from(variant: Wuf21) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF21` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf21R = crate::BitReader<Wuf21>;
impl Wuf21R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf21 {
        match self.bits {
            false => Wuf21::NoFlag,
            true => Wuf21::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf21::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf21::Flag
    }
}
#[doc = "Field `WUF21` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf21W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf21>;
impl<'a, REG> Wuf21W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf21::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf21::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf22 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf22> for bool {
    #[inline(always)]
    fn from(variant: Wuf22) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF22` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf22R = crate::BitReader<Wuf22>;
impl Wuf22R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf22 {
        match self.bits {
            false => Wuf22::NoFlag,
            true => Wuf22::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf22::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf22::Flag
    }
}
#[doc = "Field `WUF22` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf22W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf22>;
impl<'a, REG> Wuf22W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf22::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf22::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf23 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf23> for bool {
    #[inline(always)]
    fn from(variant: Wuf23) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF23` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf23R = crate::BitReader<Wuf23>;
impl Wuf23R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf23 {
        match self.bits {
            false => Wuf23::NoFlag,
            true => Wuf23::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf23::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf23::Flag
    }
}
#[doc = "Field `WUF23` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf23W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf23>;
impl<'a, REG> Wuf23W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf23::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf23::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf24 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf24> for bool {
    #[inline(always)]
    fn from(variant: Wuf24) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF24` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf24R = crate::BitReader<Wuf24>;
impl Wuf24R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf24 {
        match self.bits {
            false => Wuf24::NoFlag,
            true => Wuf24::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf24::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf24::Flag
    }
}
#[doc = "Field `WUF24` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf24W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf24>;
impl<'a, REG> Wuf24W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf24::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf24::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf25 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf25> for bool {
    #[inline(always)]
    fn from(variant: Wuf25) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF25` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf25R = crate::BitReader<Wuf25>;
impl Wuf25R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf25 {
        match self.bits {
            false => Wuf25::NoFlag,
            true => Wuf25::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf25::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf25::Flag
    }
}
#[doc = "Field `WUF25` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf25W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf25>;
impl<'a, REG> Wuf25W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf25::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf25::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf26 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf26> for bool {
    #[inline(always)]
    fn from(variant: Wuf26) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF26` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf26R = crate::BitReader<Wuf26>;
impl Wuf26R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf26 {
        match self.bits {
            false => Wuf26::NoFlag,
            true => Wuf26::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf26::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf26::Flag
    }
}
#[doc = "Field `WUF26` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf26W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf26>;
impl<'a, REG> Wuf26W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf26::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf26::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf27 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf27> for bool {
    #[inline(always)]
    fn from(variant: Wuf27) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF27` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf27R = crate::BitReader<Wuf27>;
impl Wuf27R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf27 {
        match self.bits {
            false => Wuf27::NoFlag,
            true => Wuf27::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf27::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf27::Flag
    }
}
#[doc = "Field `WUF27` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf27W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf27>;
impl<'a, REG> Wuf27W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf27::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf27::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf28 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf28> for bool {
    #[inline(always)]
    fn from(variant: Wuf28) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF28` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf28R = crate::BitReader<Wuf28>;
impl Wuf28R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf28 {
        match self.bits {
            false => Wuf28::NoFlag,
            true => Wuf28::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf28::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf28::Flag
    }
}
#[doc = "Field `WUF28` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf28W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf28>;
impl<'a, REG> Wuf28W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf28::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf28::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf29 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf29> for bool {
    #[inline(always)]
    fn from(variant: Wuf29) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF29` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf29R = crate::BitReader<Wuf29>;
impl Wuf29R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf29 {
        match self.bits {
            false => Wuf29::NoFlag,
            true => Wuf29::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf29::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf29::Flag
    }
}
#[doc = "Field `WUF29` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf29W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf29>;
impl<'a, REG> Wuf29W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf29::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf29::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf30 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf30> for bool {
    #[inline(always)]
    fn from(variant: Wuf30) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF30` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf30R = crate::BitReader<Wuf30>;
impl Wuf30R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf30 {
        match self.bits {
            false => Wuf30::NoFlag,
            true => Wuf30::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf30::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf30::Flag
    }
}
#[doc = "Field `WUF30` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf30W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf30>;
impl<'a, REG> Wuf30W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf30::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf30::Flag)
    }
}
#[doc = "Wake-up Flag for WUU_Pn\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wuf31 {
    #[doc = "0: No"]
    NoFlag = 0,
    #[doc = "1: Yes"]
    Flag = 1,
}
impl From<Wuf31> for bool {
    #[inline(always)]
    fn from(variant: Wuf31) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WUF31` reader - Wake-up Flag for WUU_Pn"]
pub type Wuf31R = crate::BitReader<Wuf31>;
impl Wuf31R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wuf31 {
        match self.bits {
            false => Wuf31::NoFlag,
            true => Wuf31::Flag,
        }
    }
    #[doc = "No"]
    #[inline(always)]
    pub fn is_no_flag(&self) -> bool {
        *self == Wuf31::NoFlag
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn is_flag(&self) -> bool {
        *self == Wuf31::Flag
    }
}
#[doc = "Field `WUF31` writer - Wake-up Flag for WUU_Pn"]
pub type Wuf31W<'a, REG> = crate::BitWriter1C<'a, REG, Wuf31>;
impl<'a, REG> Wuf31W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No"]
    #[inline(always)]
    pub fn no_flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf31::NoFlag)
    }
    #[doc = "Yes"]
    #[inline(always)]
    pub fn flag(self) -> &'a mut crate::W<REG> {
        self.variant(Wuf31::Flag)
    }
}
impl R {
    #[doc = "Bit 0 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf0(&self) -> Wuf0R {
        Wuf0R::new((self.bits & 1) != 0)
    }
    #[doc = "Bit 1 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf1(&self) -> Wuf1R {
        Wuf1R::new(((self.bits >> 1) & 1) != 0)
    }
    #[doc = "Bit 2 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf2(&self) -> Wuf2R {
        Wuf2R::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf3(&self) -> Wuf3R {
        Wuf3R::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 4 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf4(&self) -> Wuf4R {
        Wuf4R::new(((self.bits >> 4) & 1) != 0)
    }
    #[doc = "Bit 5 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf5(&self) -> Wuf5R {
        Wuf5R::new(((self.bits >> 5) & 1) != 0)
    }
    #[doc = "Bit 6 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf6(&self) -> Wuf6R {
        Wuf6R::new(((self.bits >> 6) & 1) != 0)
    }
    #[doc = "Bit 7 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf7(&self) -> Wuf7R {
        Wuf7R::new(((self.bits >> 7) & 1) != 0)
    }
    #[doc = "Bit 8 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf8(&self) -> Wuf8R {
        Wuf8R::new(((self.bits >> 8) & 1) != 0)
    }
    #[doc = "Bit 9 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf9(&self) -> Wuf9R {
        Wuf9R::new(((self.bits >> 9) & 1) != 0)
    }
    #[doc = "Bit 10 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf10(&self) -> Wuf10R {
        Wuf10R::new(((self.bits >> 10) & 1) != 0)
    }
    #[doc = "Bit 11 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf11(&self) -> Wuf11R {
        Wuf11R::new(((self.bits >> 11) & 1) != 0)
    }
    #[doc = "Bit 12 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf12(&self) -> Wuf12R {
        Wuf12R::new(((self.bits >> 12) & 1) != 0)
    }
    #[doc = "Bit 13 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf13(&self) -> Wuf13R {
        Wuf13R::new(((self.bits >> 13) & 1) != 0)
    }
    #[doc = "Bit 14 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf14(&self) -> Wuf14R {
        Wuf14R::new(((self.bits >> 14) & 1) != 0)
    }
    #[doc = "Bit 15 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf15(&self) -> Wuf15R {
        Wuf15R::new(((self.bits >> 15) & 1) != 0)
    }
    #[doc = "Bit 16 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf16(&self) -> Wuf16R {
        Wuf16R::new(((self.bits >> 16) & 1) != 0)
    }
    #[doc = "Bit 17 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf17(&self) -> Wuf17R {
        Wuf17R::new(((self.bits >> 17) & 1) != 0)
    }
    #[doc = "Bit 18 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf18(&self) -> Wuf18R {
        Wuf18R::new(((self.bits >> 18) & 1) != 0)
    }
    #[doc = "Bit 19 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf19(&self) -> Wuf19R {
        Wuf19R::new(((self.bits >> 19) & 1) != 0)
    }
    #[doc = "Bit 20 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf20(&self) -> Wuf20R {
        Wuf20R::new(((self.bits >> 20) & 1) != 0)
    }
    #[doc = "Bit 21 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf21(&self) -> Wuf21R {
        Wuf21R::new(((self.bits >> 21) & 1) != 0)
    }
    #[doc = "Bit 22 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf22(&self) -> Wuf22R {
        Wuf22R::new(((self.bits >> 22) & 1) != 0)
    }
    #[doc = "Bit 23 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf23(&self) -> Wuf23R {
        Wuf23R::new(((self.bits >> 23) & 1) != 0)
    }
    #[doc = "Bit 24 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf24(&self) -> Wuf24R {
        Wuf24R::new(((self.bits >> 24) & 1) != 0)
    }
    #[doc = "Bit 25 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf25(&self) -> Wuf25R {
        Wuf25R::new(((self.bits >> 25) & 1) != 0)
    }
    #[doc = "Bit 26 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf26(&self) -> Wuf26R {
        Wuf26R::new(((self.bits >> 26) & 1) != 0)
    }
    #[doc = "Bit 27 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf27(&self) -> Wuf27R {
        Wuf27R::new(((self.bits >> 27) & 1) != 0)
    }
    #[doc = "Bit 28 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf28(&self) -> Wuf28R {
        Wuf28R::new(((self.bits >> 28) & 1) != 0)
    }
    #[doc = "Bit 29 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf29(&self) -> Wuf29R {
        Wuf29R::new(((self.bits >> 29) & 1) != 0)
    }
    #[doc = "Bit 30 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf30(&self) -> Wuf30R {
        Wuf30R::new(((self.bits >> 30) & 1) != 0)
    }
    #[doc = "Bit 31 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf31(&self) -> Wuf31R {
        Wuf31R::new(((self.bits >> 31) & 1) != 0)
    }
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PF")
            .field("wuf0", &self.wuf0())
            .field("wuf1", &self.wuf1())
            .field("wuf2", &self.wuf2())
            .field("wuf3", &self.wuf3())
            .field("wuf4", &self.wuf4())
            .field("wuf5", &self.wuf5())
            .field("wuf6", &self.wuf6())
            .field("wuf7", &self.wuf7())
            .field("wuf8", &self.wuf8())
            .field("wuf9", &self.wuf9())
            .field("wuf10", &self.wuf10())
            .field("wuf11", &self.wuf11())
            .field("wuf12", &self.wuf12())
            .field("wuf13", &self.wuf13())
            .field("wuf14", &self.wuf14())
            .field("wuf15", &self.wuf15())
            .field("wuf16", &self.wuf16())
            .field("wuf17", &self.wuf17())
            .field("wuf18", &self.wuf18())
            .field("wuf19", &self.wuf19())
            .field("wuf20", &self.wuf20())
            .field("wuf21", &self.wuf21())
            .field("wuf22", &self.wuf22())
            .field("wuf23", &self.wuf23())
            .field("wuf24", &self.wuf24())
            .field("wuf25", &self.wuf25())
            .field("wuf26", &self.wuf26())
            .field("wuf27", &self.wuf27())
            .field("wuf28", &self.wuf28())
            .field("wuf29", &self.wuf29())
            .field("wuf30", &self.wuf30())
            .field("wuf31", &self.wuf31())
            .finish()
    }
}
impl W {
    #[doc = "Bit 0 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf0(&mut self) -> Wuf0W<'_, PfSpec> {
        Wuf0W::new(self, 0)
    }
    #[doc = "Bit 1 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf1(&mut self) -> Wuf1W<'_, PfSpec> {
        Wuf1W::new(self, 1)
    }
    #[doc = "Bit 2 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf2(&mut self) -> Wuf2W<'_, PfSpec> {
        Wuf2W::new(self, 2)
    }
    #[doc = "Bit 3 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf3(&mut self) -> Wuf3W<'_, PfSpec> {
        Wuf3W::new(self, 3)
    }
    #[doc = "Bit 4 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf4(&mut self) -> Wuf4W<'_, PfSpec> {
        Wuf4W::new(self, 4)
    }
    #[doc = "Bit 5 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf5(&mut self) -> Wuf5W<'_, PfSpec> {
        Wuf5W::new(self, 5)
    }
    #[doc = "Bit 6 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf6(&mut self) -> Wuf6W<'_, PfSpec> {
        Wuf6W::new(self, 6)
    }
    #[doc = "Bit 7 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf7(&mut self) -> Wuf7W<'_, PfSpec> {
        Wuf7W::new(self, 7)
    }
    #[doc = "Bit 8 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf8(&mut self) -> Wuf8W<'_, PfSpec> {
        Wuf8W::new(self, 8)
    }
    #[doc = "Bit 9 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf9(&mut self) -> Wuf9W<'_, PfSpec> {
        Wuf9W::new(self, 9)
    }
    #[doc = "Bit 10 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf10(&mut self) -> Wuf10W<'_, PfSpec> {
        Wuf10W::new(self, 10)
    }
    #[doc = "Bit 11 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf11(&mut self) -> Wuf11W<'_, PfSpec> {
        Wuf11W::new(self, 11)
    }
    #[doc = "Bit 12 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf12(&mut self) -> Wuf12W<'_, PfSpec> {
        Wuf12W::new(self, 12)
    }
    #[doc = "Bit 13 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf13(&mut self) -> Wuf13W<'_, PfSpec> {
        Wuf13W::new(self, 13)
    }
    #[doc = "Bit 14 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf14(&mut self) -> Wuf14W<'_, PfSpec> {
        Wuf14W::new(self, 14)
    }
    #[doc = "Bit 15 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf15(&mut self) -> Wuf15W<'_, PfSpec> {
        Wuf15W::new(self, 15)
    }
    #[doc = "Bit 16 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf16(&mut self) -> Wuf16W<'_, PfSpec> {
        Wuf16W::new(self, 16)
    }
    #[doc = "Bit 17 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf17(&mut self) -> Wuf17W<'_, PfSpec> {
        Wuf17W::new(self, 17)
    }
    #[doc = "Bit 18 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf18(&mut self) -> Wuf18W<'_, PfSpec> {
        Wuf18W::new(self, 18)
    }
    #[doc = "Bit 19 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf19(&mut self) -> Wuf19W<'_, PfSpec> {
        Wuf19W::new(self, 19)
    }
    #[doc = "Bit 20 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf20(&mut self) -> Wuf20W<'_, PfSpec> {
        Wuf20W::new(self, 20)
    }
    #[doc = "Bit 21 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf21(&mut self) -> Wuf21W<'_, PfSpec> {
        Wuf21W::new(self, 21)
    }
    #[doc = "Bit 22 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf22(&mut self) -> Wuf22W<'_, PfSpec> {
        Wuf22W::new(self, 22)
    }
    #[doc = "Bit 23 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf23(&mut self) -> Wuf23W<'_, PfSpec> {
        Wuf23W::new(self, 23)
    }
    #[doc = "Bit 24 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf24(&mut self) -> Wuf24W<'_, PfSpec> {
        Wuf24W::new(self, 24)
    }
    #[doc = "Bit 25 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf25(&mut self) -> Wuf25W<'_, PfSpec> {
        Wuf25W::new(self, 25)
    }
    #[doc = "Bit 26 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf26(&mut self) -> Wuf26W<'_, PfSpec> {
        Wuf26W::new(self, 26)
    }
    #[doc = "Bit 27 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf27(&mut self) -> Wuf27W<'_, PfSpec> {
        Wuf27W::new(self, 27)
    }
    #[doc = "Bit 28 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf28(&mut self) -> Wuf28W<'_, PfSpec> {
        Wuf28W::new(self, 28)
    }
    #[doc = "Bit 29 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf29(&mut self) -> Wuf29W<'_, PfSpec> {
        Wuf29W::new(self, 29)
    }
    #[doc = "Bit 30 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf30(&mut self) -> Wuf30W<'_, PfSpec> {
        Wuf30W::new(self, 30)
    }
    #[doc = "Bit 31 - Wake-up Flag for WUU_Pn"]
    #[inline(always)]
    pub fn wuf31(&mut self) -> Wuf31W<'_, PfSpec> {
        Wuf31W::new(self, 31)
    }
}
#[doc = "Pin Flag\n\nYou can [`read`](crate::Reg::read) this register and get [`pf::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`pf::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct PfSpec;
impl crate::RegisterSpec for PfSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`pf::R`](R) reader structure"]
impl crate::Readable for PfSpec {}
#[doc = "`write(|w| ..)` method takes [`pf::W`](W) writer structure"]
impl crate::Writable for PfSpec {
    type Safety = crate::Unsafe;
    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0xffff_ffff;
}
#[doc = "`reset()` method sets PF to value 0"]
impl crate::Resettable for PfSpec {}
