#[doc = "Register `MCR` reader"]
pub type R = crate::R<McrSpec>;
#[doc = "Register `MCR` writer"]
pub type W = crate::W<McrSpec>;
#[doc = "Interrupt on MR0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr0i {
    #[doc = "0: Does not generate"]
    Mr0i0 = 0,
    #[doc = "1: Generates"]
    Mr0i1 = 1,
}
impl From<Mr0i> for bool {
    #[inline(always)]
    fn from(variant: Mr0i) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR0I` reader - Interrupt on MR0"]
pub type Mr0iR = crate::BitReader<Mr0i>;
impl Mr0iR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr0i {
        match self.bits {
            false => Mr0i::Mr0i0,
            true => Mr0i::Mr0i1,
        }
    }
    #[doc = "Does not generate"]
    #[inline(always)]
    pub fn is_mr0i_0(&self) -> bool {
        *self == Mr0i::Mr0i0
    }
    #[doc = "Generates"]
    #[inline(always)]
    pub fn is_mr0i_1(&self) -> bool {
        *self == Mr0i::Mr0i1
    }
}
#[doc = "Field `MR0I` writer - Interrupt on MR0"]
pub type Mr0iW<'a, REG> = crate::BitWriter<'a, REG, Mr0i>;
impl<'a, REG> Mr0iW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not generate"]
    #[inline(always)]
    pub fn mr0i_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr0i::Mr0i0)
    }
    #[doc = "Generates"]
    #[inline(always)]
    pub fn mr0i_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr0i::Mr0i1)
    }
}
#[doc = "Reset on MR0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr0r {
    #[doc = "0: Does not reset"]
    Mr0r0 = 0,
    #[doc = "1: Resets"]
    Mr0r1 = 1,
}
impl From<Mr0r> for bool {
    #[inline(always)]
    fn from(variant: Mr0r) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR0R` reader - Reset on MR0"]
pub type Mr0rR = crate::BitReader<Mr0r>;
impl Mr0rR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr0r {
        match self.bits {
            false => Mr0r::Mr0r0,
            true => Mr0r::Mr0r1,
        }
    }
    #[doc = "Does not reset"]
    #[inline(always)]
    pub fn is_mr0r_0(&self) -> bool {
        *self == Mr0r::Mr0r0
    }
    #[doc = "Resets"]
    #[inline(always)]
    pub fn is_mr0r_1(&self) -> bool {
        *self == Mr0r::Mr0r1
    }
}
#[doc = "Field `MR0R` writer - Reset on MR0"]
pub type Mr0rW<'a, REG> = crate::BitWriter<'a, REG, Mr0r>;
impl<'a, REG> Mr0rW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not reset"]
    #[inline(always)]
    pub fn mr0r_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr0r::Mr0r0)
    }
    #[doc = "Resets"]
    #[inline(always)]
    pub fn mr0r_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr0r::Mr0r1)
    }
}
#[doc = "Stop on MR0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr0s {
    #[doc = "0: Does not stop"]
    Mr0s0 = 0,
    #[doc = "1: Stops"]
    Mr0s1 = 1,
}
impl From<Mr0s> for bool {
    #[inline(always)]
    fn from(variant: Mr0s) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR0S` reader - Stop on MR0"]
pub type Mr0sR = crate::BitReader<Mr0s>;
impl Mr0sR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr0s {
        match self.bits {
            false => Mr0s::Mr0s0,
            true => Mr0s::Mr0s1,
        }
    }
    #[doc = "Does not stop"]
    #[inline(always)]
    pub fn is_mr0s_0(&self) -> bool {
        *self == Mr0s::Mr0s0
    }
    #[doc = "Stops"]
    #[inline(always)]
    pub fn is_mr0s_1(&self) -> bool {
        *self == Mr0s::Mr0s1
    }
}
#[doc = "Field `MR0S` writer - Stop on MR0"]
pub type Mr0sW<'a, REG> = crate::BitWriter<'a, REG, Mr0s>;
impl<'a, REG> Mr0sW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not stop"]
    #[inline(always)]
    pub fn mr0s_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr0s::Mr0s0)
    }
    #[doc = "Stops"]
    #[inline(always)]
    pub fn mr0s_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr0s::Mr0s1)
    }
}
#[doc = "Interrupt on MR1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr1i {
    #[doc = "0: Does not generate"]
    Mr1i0 = 0,
    #[doc = "1: Generates"]
    Mr1i1 = 1,
}
impl From<Mr1i> for bool {
    #[inline(always)]
    fn from(variant: Mr1i) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR1I` reader - Interrupt on MR1"]
pub type Mr1iR = crate::BitReader<Mr1i>;
impl Mr1iR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr1i {
        match self.bits {
            false => Mr1i::Mr1i0,
            true => Mr1i::Mr1i1,
        }
    }
    #[doc = "Does not generate"]
    #[inline(always)]
    pub fn is_mr1i_0(&self) -> bool {
        *self == Mr1i::Mr1i0
    }
    #[doc = "Generates"]
    #[inline(always)]
    pub fn is_mr1i_1(&self) -> bool {
        *self == Mr1i::Mr1i1
    }
}
#[doc = "Field `MR1I` writer - Interrupt on MR1"]
pub type Mr1iW<'a, REG> = crate::BitWriter<'a, REG, Mr1i>;
impl<'a, REG> Mr1iW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not generate"]
    #[inline(always)]
    pub fn mr1i_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr1i::Mr1i0)
    }
    #[doc = "Generates"]
    #[inline(always)]
    pub fn mr1i_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr1i::Mr1i1)
    }
}
#[doc = "Reset on MR1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr1r {
    #[doc = "0: Does not reset"]
    Mr1r0 = 0,
    #[doc = "1: Resets"]
    Mr1r1 = 1,
}
impl From<Mr1r> for bool {
    #[inline(always)]
    fn from(variant: Mr1r) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR1R` reader - Reset on MR1"]
pub type Mr1rR = crate::BitReader<Mr1r>;
impl Mr1rR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr1r {
        match self.bits {
            false => Mr1r::Mr1r0,
            true => Mr1r::Mr1r1,
        }
    }
    #[doc = "Does not reset"]
    #[inline(always)]
    pub fn is_mr1r_0(&self) -> bool {
        *self == Mr1r::Mr1r0
    }
    #[doc = "Resets"]
    #[inline(always)]
    pub fn is_mr1r_1(&self) -> bool {
        *self == Mr1r::Mr1r1
    }
}
#[doc = "Field `MR1R` writer - Reset on MR1"]
pub type Mr1rW<'a, REG> = crate::BitWriter<'a, REG, Mr1r>;
impl<'a, REG> Mr1rW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not reset"]
    #[inline(always)]
    pub fn mr1r_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr1r::Mr1r0)
    }
    #[doc = "Resets"]
    #[inline(always)]
    pub fn mr1r_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr1r::Mr1r1)
    }
}
#[doc = "Stop on MR1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr1s {
    #[doc = "0: Does not stop"]
    Mris0 = 0,
    #[doc = "1: Stops"]
    Mris1 = 1,
}
impl From<Mr1s> for bool {
    #[inline(always)]
    fn from(variant: Mr1s) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR1S` reader - Stop on MR1"]
pub type Mr1sR = crate::BitReader<Mr1s>;
impl Mr1sR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr1s {
        match self.bits {
            false => Mr1s::Mris0,
            true => Mr1s::Mris1,
        }
    }
    #[doc = "Does not stop"]
    #[inline(always)]
    pub fn is_mris_0(&self) -> bool {
        *self == Mr1s::Mris0
    }
    #[doc = "Stops"]
    #[inline(always)]
    pub fn is_mris_1(&self) -> bool {
        *self == Mr1s::Mris1
    }
}
#[doc = "Field `MR1S` writer - Stop on MR1"]
pub type Mr1sW<'a, REG> = crate::BitWriter<'a, REG, Mr1s>;
impl<'a, REG> Mr1sW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not stop"]
    #[inline(always)]
    pub fn mris_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr1s::Mris0)
    }
    #[doc = "Stops"]
    #[inline(always)]
    pub fn mris_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr1s::Mris1)
    }
}
#[doc = "Interrupt on MR2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr2i {
    #[doc = "0: Does not generate"]
    Mr2i0 = 0,
    #[doc = "1: Generates"]
    Mr2i1 = 1,
}
impl From<Mr2i> for bool {
    #[inline(always)]
    fn from(variant: Mr2i) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR2I` reader - Interrupt on MR2"]
pub type Mr2iR = crate::BitReader<Mr2i>;
impl Mr2iR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr2i {
        match self.bits {
            false => Mr2i::Mr2i0,
            true => Mr2i::Mr2i1,
        }
    }
    #[doc = "Does not generate"]
    #[inline(always)]
    pub fn is_mr2i_0(&self) -> bool {
        *self == Mr2i::Mr2i0
    }
    #[doc = "Generates"]
    #[inline(always)]
    pub fn is_mr2i_1(&self) -> bool {
        *self == Mr2i::Mr2i1
    }
}
#[doc = "Field `MR2I` writer - Interrupt on MR2"]
pub type Mr2iW<'a, REG> = crate::BitWriter<'a, REG, Mr2i>;
impl<'a, REG> Mr2iW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not generate"]
    #[inline(always)]
    pub fn mr2i_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr2i::Mr2i0)
    }
    #[doc = "Generates"]
    #[inline(always)]
    pub fn mr2i_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr2i::Mr2i1)
    }
}
#[doc = "Reset on MR2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr2r {
    #[doc = "0: Does not reset"]
    Mr2r0 = 0,
    #[doc = "1: Resets"]
    Mr2r1 = 1,
}
impl From<Mr2r> for bool {
    #[inline(always)]
    fn from(variant: Mr2r) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR2R` reader - Reset on MR2"]
pub type Mr2rR = crate::BitReader<Mr2r>;
impl Mr2rR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr2r {
        match self.bits {
            false => Mr2r::Mr2r0,
            true => Mr2r::Mr2r1,
        }
    }
    #[doc = "Does not reset"]
    #[inline(always)]
    pub fn is_mr2r_0(&self) -> bool {
        *self == Mr2r::Mr2r0
    }
    #[doc = "Resets"]
    #[inline(always)]
    pub fn is_mr2r_1(&self) -> bool {
        *self == Mr2r::Mr2r1
    }
}
#[doc = "Field `MR2R` writer - Reset on MR2"]
pub type Mr2rW<'a, REG> = crate::BitWriter<'a, REG, Mr2r>;
impl<'a, REG> Mr2rW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not reset"]
    #[inline(always)]
    pub fn mr2r_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr2r::Mr2r0)
    }
    #[doc = "Resets"]
    #[inline(always)]
    pub fn mr2r_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr2r::Mr2r1)
    }
}
#[doc = "Stop on MR2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr2s {
    #[doc = "0: Does not stop"]
    Mr2s0 = 0,
    #[doc = "1: Stops"]
    Mr2s1 = 1,
}
impl From<Mr2s> for bool {
    #[inline(always)]
    fn from(variant: Mr2s) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR2S` reader - Stop on MR2"]
pub type Mr2sR = crate::BitReader<Mr2s>;
impl Mr2sR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr2s {
        match self.bits {
            false => Mr2s::Mr2s0,
            true => Mr2s::Mr2s1,
        }
    }
    #[doc = "Does not stop"]
    #[inline(always)]
    pub fn is_mr2s_0(&self) -> bool {
        *self == Mr2s::Mr2s0
    }
    #[doc = "Stops"]
    #[inline(always)]
    pub fn is_mr2s_1(&self) -> bool {
        *self == Mr2s::Mr2s1
    }
}
#[doc = "Field `MR2S` writer - Stop on MR2"]
pub type Mr2sW<'a, REG> = crate::BitWriter<'a, REG, Mr2s>;
impl<'a, REG> Mr2sW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not stop"]
    #[inline(always)]
    pub fn mr2s_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr2s::Mr2s0)
    }
    #[doc = "Stops"]
    #[inline(always)]
    pub fn mr2s_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr2s::Mr2s1)
    }
}
#[doc = "Interrupt on MR3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr3i {
    #[doc = "0: Does not generate"]
    Mr3i0 = 0,
    #[doc = "1: Generates"]
    Mr3i1 = 1,
}
impl From<Mr3i> for bool {
    #[inline(always)]
    fn from(variant: Mr3i) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR3I` reader - Interrupt on MR3"]
pub type Mr3iR = crate::BitReader<Mr3i>;
impl Mr3iR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr3i {
        match self.bits {
            false => Mr3i::Mr3i0,
            true => Mr3i::Mr3i1,
        }
    }
    #[doc = "Does not generate"]
    #[inline(always)]
    pub fn is_mr3i_0(&self) -> bool {
        *self == Mr3i::Mr3i0
    }
    #[doc = "Generates"]
    #[inline(always)]
    pub fn is_mr3i_1(&self) -> bool {
        *self == Mr3i::Mr3i1
    }
}
#[doc = "Field `MR3I` writer - Interrupt on MR3"]
pub type Mr3iW<'a, REG> = crate::BitWriter<'a, REG, Mr3i>;
impl<'a, REG> Mr3iW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not generate"]
    #[inline(always)]
    pub fn mr3i_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr3i::Mr3i0)
    }
    #[doc = "Generates"]
    #[inline(always)]
    pub fn mr3i_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr3i::Mr3i1)
    }
}
#[doc = "Reset on MR3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr3r {
    #[doc = "0: Does not reset"]
    Mr3r0 = 0,
    #[doc = "1: Resets"]
    Mr3r1 = 1,
}
impl From<Mr3r> for bool {
    #[inline(always)]
    fn from(variant: Mr3r) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR3R` reader - Reset on MR3"]
pub type Mr3rR = crate::BitReader<Mr3r>;
impl Mr3rR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr3r {
        match self.bits {
            false => Mr3r::Mr3r0,
            true => Mr3r::Mr3r1,
        }
    }
    #[doc = "Does not reset"]
    #[inline(always)]
    pub fn is_mr3r_0(&self) -> bool {
        *self == Mr3r::Mr3r0
    }
    #[doc = "Resets"]
    #[inline(always)]
    pub fn is_mr3r_1(&self) -> bool {
        *self == Mr3r::Mr3r1
    }
}
#[doc = "Field `MR3R` writer - Reset on MR3"]
pub type Mr3rW<'a, REG> = crate::BitWriter<'a, REG, Mr3r>;
impl<'a, REG> Mr3rW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not reset"]
    #[inline(always)]
    pub fn mr3r_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr3r::Mr3r0)
    }
    #[doc = "Resets"]
    #[inline(always)]
    pub fn mr3r_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr3r::Mr3r1)
    }
}
#[doc = "Stop on MR3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr3s {
    #[doc = "0: Does not stop"]
    Mr3s0 = 0,
    #[doc = "1: Stops"]
    Mr3s1 = 1,
}
impl From<Mr3s> for bool {
    #[inline(always)]
    fn from(variant: Mr3s) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR3S` reader - Stop on MR3"]
pub type Mr3sR = crate::BitReader<Mr3s>;
impl Mr3sR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr3s {
        match self.bits {
            false => Mr3s::Mr3s0,
            true => Mr3s::Mr3s1,
        }
    }
    #[doc = "Does not stop"]
    #[inline(always)]
    pub fn is_mr3s_0(&self) -> bool {
        *self == Mr3s::Mr3s0
    }
    #[doc = "Stops"]
    #[inline(always)]
    pub fn is_mr3s_1(&self) -> bool {
        *self == Mr3s::Mr3s1
    }
}
#[doc = "Field `MR3S` writer - Stop on MR3"]
pub type Mr3sW<'a, REG> = crate::BitWriter<'a, REG, Mr3s>;
impl<'a, REG> Mr3sW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not stop"]
    #[inline(always)]
    pub fn mr3s_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr3s::Mr3s0)
    }
    #[doc = "Stops"]
    #[inline(always)]
    pub fn mr3s_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr3s::Mr3s1)
    }
}
#[doc = "Reload MR\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr0rl {
    #[doc = "0: Does not reload"]
    Mr0rl0 = 0,
    #[doc = "1: Reloads"]
    Mr0rl1 = 1,
}
impl From<Mr0rl> for bool {
    #[inline(always)]
    fn from(variant: Mr0rl) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR0RL` reader - Reload MR"]
pub type Mr0rlR = crate::BitReader<Mr0rl>;
impl Mr0rlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr0rl {
        match self.bits {
            false => Mr0rl::Mr0rl0,
            true => Mr0rl::Mr0rl1,
        }
    }
    #[doc = "Does not reload"]
    #[inline(always)]
    pub fn is_mr0rl_0(&self) -> bool {
        *self == Mr0rl::Mr0rl0
    }
    #[doc = "Reloads"]
    #[inline(always)]
    pub fn is_mr0rl_1(&self) -> bool {
        *self == Mr0rl::Mr0rl1
    }
}
#[doc = "Field `MR0RL` writer - Reload MR"]
pub type Mr0rlW<'a, REG> = crate::BitWriter<'a, REG, Mr0rl>;
impl<'a, REG> Mr0rlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not reload"]
    #[inline(always)]
    pub fn mr0rl_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr0rl::Mr0rl0)
    }
    #[doc = "Reloads"]
    #[inline(always)]
    pub fn mr0rl_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr0rl::Mr0rl1)
    }
}
#[doc = "Reload MR\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr1rl {
    #[doc = "0: Does not reload"]
    Mr1rl0 = 0,
    #[doc = "1: Reloads"]
    Mr1rl1 = 1,
}
impl From<Mr1rl> for bool {
    #[inline(always)]
    fn from(variant: Mr1rl) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR1RL` reader - Reload MR"]
pub type Mr1rlR = crate::BitReader<Mr1rl>;
impl Mr1rlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr1rl {
        match self.bits {
            false => Mr1rl::Mr1rl0,
            true => Mr1rl::Mr1rl1,
        }
    }
    #[doc = "Does not reload"]
    #[inline(always)]
    pub fn is_mr1rl_0(&self) -> bool {
        *self == Mr1rl::Mr1rl0
    }
    #[doc = "Reloads"]
    #[inline(always)]
    pub fn is_mr1rl_1(&self) -> bool {
        *self == Mr1rl::Mr1rl1
    }
}
#[doc = "Field `MR1RL` writer - Reload MR"]
pub type Mr1rlW<'a, REG> = crate::BitWriter<'a, REG, Mr1rl>;
impl<'a, REG> Mr1rlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not reload"]
    #[inline(always)]
    pub fn mr1rl_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr1rl::Mr1rl0)
    }
    #[doc = "Reloads"]
    #[inline(always)]
    pub fn mr1rl_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr1rl::Mr1rl1)
    }
}
#[doc = "Reload MR\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr2rl {
    #[doc = "0: Does not reload"]
    Mr2rl0 = 0,
    #[doc = "1: Reloads"]
    Mr2rl1 = 1,
}
impl From<Mr2rl> for bool {
    #[inline(always)]
    fn from(variant: Mr2rl) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR2RL` reader - Reload MR"]
pub type Mr2rlR = crate::BitReader<Mr2rl>;
impl Mr2rlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr2rl {
        match self.bits {
            false => Mr2rl::Mr2rl0,
            true => Mr2rl::Mr2rl1,
        }
    }
    #[doc = "Does not reload"]
    #[inline(always)]
    pub fn is_mr2rl_0(&self) -> bool {
        *self == Mr2rl::Mr2rl0
    }
    #[doc = "Reloads"]
    #[inline(always)]
    pub fn is_mr2rl_1(&self) -> bool {
        *self == Mr2rl::Mr2rl1
    }
}
#[doc = "Field `MR2RL` writer - Reload MR"]
pub type Mr2rlW<'a, REG> = crate::BitWriter<'a, REG, Mr2rl>;
impl<'a, REG> Mr2rlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not reload"]
    #[inline(always)]
    pub fn mr2rl_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr2rl::Mr2rl0)
    }
    #[doc = "Reloads"]
    #[inline(always)]
    pub fn mr2rl_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr2rl::Mr2rl1)
    }
}
#[doc = "Reload MR\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mr3rl {
    #[doc = "0: Does not reload"]
    Mr3rl0 = 0,
    #[doc = "1: Reloads"]
    Mr3rl1 = 1,
}
impl From<Mr3rl> for bool {
    #[inline(always)]
    fn from(variant: Mr3rl) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MR3RL` reader - Reload MR"]
pub type Mr3rlR = crate::BitReader<Mr3rl>;
impl Mr3rlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Mr3rl {
        match self.bits {
            false => Mr3rl::Mr3rl0,
            true => Mr3rl::Mr3rl1,
        }
    }
    #[doc = "Does not reload"]
    #[inline(always)]
    pub fn is_mr3rl_0(&self) -> bool {
        *self == Mr3rl::Mr3rl0
    }
    #[doc = "Reloads"]
    #[inline(always)]
    pub fn is_mr3rl_1(&self) -> bool {
        *self == Mr3rl::Mr3rl1
    }
}
#[doc = "Field `MR3RL` writer - Reload MR"]
pub type Mr3rlW<'a, REG> = crate::BitWriter<'a, REG, Mr3rl>;
impl<'a, REG> Mr3rlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Does not reload"]
    #[inline(always)]
    pub fn mr3rl_0(self) -> &'a mut crate::W<REG> {
        self.variant(Mr3rl::Mr3rl0)
    }
    #[doc = "Reloads"]
    #[inline(always)]
    pub fn mr3rl_1(self) -> &'a mut crate::W<REG> {
        self.variant(Mr3rl::Mr3rl1)
    }
}
impl R {
    #[doc = "Bit 0 - Interrupt on MR0"]
    #[inline(always)]
    pub fn mr0i(&self) -> Mr0iR {
        Mr0iR::new((self.bits & 1) != 0)
    }
    #[doc = "Bit 1 - Reset on MR0"]
    #[inline(always)]
    pub fn mr0r(&self) -> Mr0rR {
        Mr0rR::new(((self.bits >> 1) & 1) != 0)
    }
    #[doc = "Bit 2 - Stop on MR0"]
    #[inline(always)]
    pub fn mr0s(&self) -> Mr0sR {
        Mr0sR::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - Interrupt on MR1"]
    #[inline(always)]
    pub fn mr1i(&self) -> Mr1iR {
        Mr1iR::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 4 - Reset on MR1"]
    #[inline(always)]
    pub fn mr1r(&self) -> Mr1rR {
        Mr1rR::new(((self.bits >> 4) & 1) != 0)
    }
    #[doc = "Bit 5 - Stop on MR1"]
    #[inline(always)]
    pub fn mr1s(&self) -> Mr1sR {
        Mr1sR::new(((self.bits >> 5) & 1) != 0)
    }
    #[doc = "Bit 6 - Interrupt on MR2"]
    #[inline(always)]
    pub fn mr2i(&self) -> Mr2iR {
        Mr2iR::new(((self.bits >> 6) & 1) != 0)
    }
    #[doc = "Bit 7 - Reset on MR2"]
    #[inline(always)]
    pub fn mr2r(&self) -> Mr2rR {
        Mr2rR::new(((self.bits >> 7) & 1) != 0)
    }
    #[doc = "Bit 8 - Stop on MR2"]
    #[inline(always)]
    pub fn mr2s(&self) -> Mr2sR {
        Mr2sR::new(((self.bits >> 8) & 1) != 0)
    }
    #[doc = "Bit 9 - Interrupt on MR3"]
    #[inline(always)]
    pub fn mr3i(&self) -> Mr3iR {
        Mr3iR::new(((self.bits >> 9) & 1) != 0)
    }
    #[doc = "Bit 10 - Reset on MR3"]
    #[inline(always)]
    pub fn mr3r(&self) -> Mr3rR {
        Mr3rR::new(((self.bits >> 10) & 1) != 0)
    }
    #[doc = "Bit 11 - Stop on MR3"]
    #[inline(always)]
    pub fn mr3s(&self) -> Mr3sR {
        Mr3sR::new(((self.bits >> 11) & 1) != 0)
    }
    #[doc = "Bit 24 - Reload MR"]
    #[inline(always)]
    pub fn mr0rl(&self) -> Mr0rlR {
        Mr0rlR::new(((self.bits >> 24) & 1) != 0)
    }
    #[doc = "Bit 25 - Reload MR"]
    #[inline(always)]
    pub fn mr1rl(&self) -> Mr1rlR {
        Mr1rlR::new(((self.bits >> 25) & 1) != 0)
    }
    #[doc = "Bit 26 - Reload MR"]
    #[inline(always)]
    pub fn mr2rl(&self) -> Mr2rlR {
        Mr2rlR::new(((self.bits >> 26) & 1) != 0)
    }
    #[doc = "Bit 27 - Reload MR"]
    #[inline(always)]
    pub fn mr3rl(&self) -> Mr3rlR {
        Mr3rlR::new(((self.bits >> 27) & 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("MCR")
            .field("mr0i", &self.mr0i())
            .field("mr0r", &self.mr0r())
            .field("mr0s", &self.mr0s())
            .field("mr1i", &self.mr1i())
            .field("mr1r", &self.mr1r())
            .field("mr1s", &self.mr1s())
            .field("mr2i", &self.mr2i())
            .field("mr2r", &self.mr2r())
            .field("mr2s", &self.mr2s())
            .field("mr3i", &self.mr3i())
            .field("mr3r", &self.mr3r())
            .field("mr3s", &self.mr3s())
            .field("mr0rl", &self.mr0rl())
            .field("mr1rl", &self.mr1rl())
            .field("mr2rl", &self.mr2rl())
            .field("mr3rl", &self.mr3rl())
            .finish()
    }
}
impl W {
    #[doc = "Bit 0 - Interrupt on MR0"]
    #[inline(always)]
    pub fn mr0i(&mut self) -> Mr0iW<'_, McrSpec> {
        Mr0iW::new(self, 0)
    }
    #[doc = "Bit 1 - Reset on MR0"]
    #[inline(always)]
    pub fn mr0r(&mut self) -> Mr0rW<'_, McrSpec> {
        Mr0rW::new(self, 1)
    }
    #[doc = "Bit 2 - Stop on MR0"]
    #[inline(always)]
    pub fn mr0s(&mut self) -> Mr0sW<'_, McrSpec> {
        Mr0sW::new(self, 2)
    }
    #[doc = "Bit 3 - Interrupt on MR1"]
    #[inline(always)]
    pub fn mr1i(&mut self) -> Mr1iW<'_, McrSpec> {
        Mr1iW::new(self, 3)
    }
    #[doc = "Bit 4 - Reset on MR1"]
    #[inline(always)]
    pub fn mr1r(&mut self) -> Mr1rW<'_, McrSpec> {
        Mr1rW::new(self, 4)
    }
    #[doc = "Bit 5 - Stop on MR1"]
    #[inline(always)]
    pub fn mr1s(&mut self) -> Mr1sW<'_, McrSpec> {
        Mr1sW::new(self, 5)
    }
    #[doc = "Bit 6 - Interrupt on MR2"]
    #[inline(always)]
    pub fn mr2i(&mut self) -> Mr2iW<'_, McrSpec> {
        Mr2iW::new(self, 6)
    }
    #[doc = "Bit 7 - Reset on MR2"]
    #[inline(always)]
    pub fn mr2r(&mut self) -> Mr2rW<'_, McrSpec> {
        Mr2rW::new(self, 7)
    }
    #[doc = "Bit 8 - Stop on MR2"]
    #[inline(always)]
    pub fn mr2s(&mut self) -> Mr2sW<'_, McrSpec> {
        Mr2sW::new(self, 8)
    }
    #[doc = "Bit 9 - Interrupt on MR3"]
    #[inline(always)]
    pub fn mr3i(&mut self) -> Mr3iW<'_, McrSpec> {
        Mr3iW::new(self, 9)
    }
    #[doc = "Bit 10 - Reset on MR3"]
    #[inline(always)]
    pub fn mr3r(&mut self) -> Mr3rW<'_, McrSpec> {
        Mr3rW::new(self, 10)
    }
    #[doc = "Bit 11 - Stop on MR3"]
    #[inline(always)]
    pub fn mr3s(&mut self) -> Mr3sW<'_, McrSpec> {
        Mr3sW::new(self, 11)
    }
    #[doc = "Bit 24 - Reload MR"]
    #[inline(always)]
    pub fn mr0rl(&mut self) -> Mr0rlW<'_, McrSpec> {
        Mr0rlW::new(self, 24)
    }
    #[doc = "Bit 25 - Reload MR"]
    #[inline(always)]
    pub fn mr1rl(&mut self) -> Mr1rlW<'_, McrSpec> {
        Mr1rlW::new(self, 25)
    }
    #[doc = "Bit 26 - Reload MR"]
    #[inline(always)]
    pub fn mr2rl(&mut self) -> Mr2rlW<'_, McrSpec> {
        Mr2rlW::new(self, 26)
    }
    #[doc = "Bit 27 - Reload MR"]
    #[inline(always)]
    pub fn mr3rl(&mut self) -> Mr3rlW<'_, McrSpec> {
        Mr3rlW::new(self, 27)
    }
}
#[doc = "Match Control\n\nYou can [`read`](crate::Reg::read) this register and get [`mcr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`mcr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct McrSpec;
impl crate::RegisterSpec for McrSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`mcr::R`](R) reader structure"]
impl crate::Readable for McrSpec {}
#[doc = "`write(|w| ..)` method takes [`mcr::W`](W) writer structure"]
impl crate::Writable for McrSpec {
    type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets MCR to value 0"]
impl crate::Resettable for McrSpec {}
