#[doc = r" Value read from the register"]
pub struct R {
    bits: u32,
}
#[doc = r" Value to write to the register"]
pub struct W {
    bits: u32,
}
impl super::ADC14IER0 {
    #[doc = r" Modifies the contents of the register"]
    #[inline]
    pub fn modify<F>(&self, f: F)
    where
        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
    {
        let bits = self.register.get();
        let r = R { bits: bits };
        let mut w = W { bits: bits };
        f(&r, &mut w);
        self.register.set(w.bits);
    }
    #[doc = r" Reads the contents of the register"]
    #[inline]
    pub fn read(&self) -> R {
        R {
            bits: self.register.get(),
        }
    }
    #[doc = r" Writes to the register"]
    #[inline]
    pub fn write<F>(&self, f: F)
    where
        F: FnOnce(&mut W) -> &mut W,
    {
        let mut w = W::reset_value();
        f(&mut w);
        self.register.set(w.bits);
    }
    #[doc = r" Writes the reset value to the register"]
    #[inline]
    pub fn reset(&self) {
        self.write(|w| w)
    }
}
#[doc = "Possible values of the field `ADC14IE0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE0R {
    #[doc = "Interrupt disabled"]
    ADC14IE0_0,
    #[doc = "Interrupt enabled"]
    ADC14IE0_1,
}
impl ADC14IE0R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE0R::ADC14IE0_0 => false,
            ADC14IE0R::ADC14IE0_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE0R {
        match value {
            false => ADC14IE0R::ADC14IE0_0,
            true => ADC14IE0R::ADC14IE0_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE0_0`"]
    #[inline]
    pub fn is_adc14ie0_0(&self) -> bool {
        *self == ADC14IE0R::ADC14IE0_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE0_1`"]
    #[inline]
    pub fn is_adc14ie0_1(&self) -> bool {
        *self == ADC14IE0R::ADC14IE0_1
    }
}
#[doc = "Possible values of the field `ADC14IE1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE1R {
    #[doc = "Interrupt disabled"]
    ADC14IE1_0,
    #[doc = "Interrupt enabled"]
    ADC14IE1_1,
}
impl ADC14IE1R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE1R::ADC14IE1_0 => false,
            ADC14IE1R::ADC14IE1_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE1R {
        match value {
            false => ADC14IE1R::ADC14IE1_0,
            true => ADC14IE1R::ADC14IE1_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE1_0`"]
    #[inline]
    pub fn is_adc14ie1_0(&self) -> bool {
        *self == ADC14IE1R::ADC14IE1_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE1_1`"]
    #[inline]
    pub fn is_adc14ie1_1(&self) -> bool {
        *self == ADC14IE1R::ADC14IE1_1
    }
}
#[doc = "Possible values of the field `ADC14IE2`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE2R {
    #[doc = "Interrupt disabled"]
    ADC14IE2_0,
    #[doc = "Interrupt enabled"]
    ADC14IE2_1,
}
impl ADC14IE2R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE2R::ADC14IE2_0 => false,
            ADC14IE2R::ADC14IE2_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE2R {
        match value {
            false => ADC14IE2R::ADC14IE2_0,
            true => ADC14IE2R::ADC14IE2_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE2_0`"]
    #[inline]
    pub fn is_adc14ie2_0(&self) -> bool {
        *self == ADC14IE2R::ADC14IE2_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE2_1`"]
    #[inline]
    pub fn is_adc14ie2_1(&self) -> bool {
        *self == ADC14IE2R::ADC14IE2_1
    }
}
#[doc = "Possible values of the field `ADC14IE3`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE3R {
    #[doc = "Interrupt disabled"]
    ADC14IE3_0,
    #[doc = "Interrupt enabled"]
    ADC14IE3_1,
}
impl ADC14IE3R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE3R::ADC14IE3_0 => false,
            ADC14IE3R::ADC14IE3_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE3R {
        match value {
            false => ADC14IE3R::ADC14IE3_0,
            true => ADC14IE3R::ADC14IE3_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE3_0`"]
    #[inline]
    pub fn is_adc14ie3_0(&self) -> bool {
        *self == ADC14IE3R::ADC14IE3_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE3_1`"]
    #[inline]
    pub fn is_adc14ie3_1(&self) -> bool {
        *self == ADC14IE3R::ADC14IE3_1
    }
}
#[doc = "Possible values of the field `ADC14IE4`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE4R {
    #[doc = "Interrupt disabled"]
    ADC14IE4_0,
    #[doc = "Interrupt enabled"]
    ADC14IE4_1,
}
impl ADC14IE4R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE4R::ADC14IE4_0 => false,
            ADC14IE4R::ADC14IE4_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE4R {
        match value {
            false => ADC14IE4R::ADC14IE4_0,
            true => ADC14IE4R::ADC14IE4_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE4_0`"]
    #[inline]
    pub fn is_adc14ie4_0(&self) -> bool {
        *self == ADC14IE4R::ADC14IE4_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE4_1`"]
    #[inline]
    pub fn is_adc14ie4_1(&self) -> bool {
        *self == ADC14IE4R::ADC14IE4_1
    }
}
#[doc = "Possible values of the field `ADC14IE5`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE5R {
    #[doc = "Interrupt disabled"]
    ADC14IE5_0,
    #[doc = "Interrupt enabled"]
    ADC14IE5_1,
}
impl ADC14IE5R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE5R::ADC14IE5_0 => false,
            ADC14IE5R::ADC14IE5_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE5R {
        match value {
            false => ADC14IE5R::ADC14IE5_0,
            true => ADC14IE5R::ADC14IE5_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE5_0`"]
    #[inline]
    pub fn is_adc14ie5_0(&self) -> bool {
        *self == ADC14IE5R::ADC14IE5_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE5_1`"]
    #[inline]
    pub fn is_adc14ie5_1(&self) -> bool {
        *self == ADC14IE5R::ADC14IE5_1
    }
}
#[doc = "Possible values of the field `ADC14IE6`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE6R {
    #[doc = "Interrupt disabled"]
    ADC14IE6_0,
    #[doc = "Interrupt enabled"]
    ADC14IE6_1,
}
impl ADC14IE6R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE6R::ADC14IE6_0 => false,
            ADC14IE6R::ADC14IE6_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE6R {
        match value {
            false => ADC14IE6R::ADC14IE6_0,
            true => ADC14IE6R::ADC14IE6_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE6_0`"]
    #[inline]
    pub fn is_adc14ie6_0(&self) -> bool {
        *self == ADC14IE6R::ADC14IE6_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE6_1`"]
    #[inline]
    pub fn is_adc14ie6_1(&self) -> bool {
        *self == ADC14IE6R::ADC14IE6_1
    }
}
#[doc = "Possible values of the field `ADC14IE7`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE7R {
    #[doc = "Interrupt disabled"]
    ADC14IE7_0,
    #[doc = "Interrupt enabled"]
    ADC14IE7_1,
}
impl ADC14IE7R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE7R::ADC14IE7_0 => false,
            ADC14IE7R::ADC14IE7_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE7R {
        match value {
            false => ADC14IE7R::ADC14IE7_0,
            true => ADC14IE7R::ADC14IE7_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE7_0`"]
    #[inline]
    pub fn is_adc14ie7_0(&self) -> bool {
        *self == ADC14IE7R::ADC14IE7_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE7_1`"]
    #[inline]
    pub fn is_adc14ie7_1(&self) -> bool {
        *self == ADC14IE7R::ADC14IE7_1
    }
}
#[doc = "Possible values of the field `ADC14IE8`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE8R {
    #[doc = "Interrupt disabled"]
    ADC14IE8_0,
    #[doc = "Interrupt enabled"]
    ADC14IE8_1,
}
impl ADC14IE8R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE8R::ADC14IE8_0 => false,
            ADC14IE8R::ADC14IE8_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE8R {
        match value {
            false => ADC14IE8R::ADC14IE8_0,
            true => ADC14IE8R::ADC14IE8_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE8_0`"]
    #[inline]
    pub fn is_adc14ie8_0(&self) -> bool {
        *self == ADC14IE8R::ADC14IE8_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE8_1`"]
    #[inline]
    pub fn is_adc14ie8_1(&self) -> bool {
        *self == ADC14IE8R::ADC14IE8_1
    }
}
#[doc = "Possible values of the field `ADC14IE9`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE9R {
    #[doc = "Interrupt disabled"]
    ADC14IE9_0,
    #[doc = "Interrupt enabled"]
    ADC14IE9_1,
}
impl ADC14IE9R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE9R::ADC14IE9_0 => false,
            ADC14IE9R::ADC14IE9_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE9R {
        match value {
            false => ADC14IE9R::ADC14IE9_0,
            true => ADC14IE9R::ADC14IE9_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE9_0`"]
    #[inline]
    pub fn is_adc14ie9_0(&self) -> bool {
        *self == ADC14IE9R::ADC14IE9_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE9_1`"]
    #[inline]
    pub fn is_adc14ie9_1(&self) -> bool {
        *self == ADC14IE9R::ADC14IE9_1
    }
}
#[doc = "Possible values of the field `ADC14IE10`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE10R {
    #[doc = "Interrupt disabled"]
    ADC14IE10_0,
    #[doc = "Interrupt enabled"]
    ADC14IE10_1,
}
impl ADC14IE10R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE10R::ADC14IE10_0 => false,
            ADC14IE10R::ADC14IE10_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE10R {
        match value {
            false => ADC14IE10R::ADC14IE10_0,
            true => ADC14IE10R::ADC14IE10_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE10_0`"]
    #[inline]
    pub fn is_adc14ie10_0(&self) -> bool {
        *self == ADC14IE10R::ADC14IE10_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE10_1`"]
    #[inline]
    pub fn is_adc14ie10_1(&self) -> bool {
        *self == ADC14IE10R::ADC14IE10_1
    }
}
#[doc = "Possible values of the field `ADC14IE11`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE11R {
    #[doc = "Interrupt disabled"]
    ADC14IE11_0,
    #[doc = "Interrupt enabled"]
    ADC14IE11_1,
}
impl ADC14IE11R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE11R::ADC14IE11_0 => false,
            ADC14IE11R::ADC14IE11_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE11R {
        match value {
            false => ADC14IE11R::ADC14IE11_0,
            true => ADC14IE11R::ADC14IE11_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE11_0`"]
    #[inline]
    pub fn is_adc14ie11_0(&self) -> bool {
        *self == ADC14IE11R::ADC14IE11_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE11_1`"]
    #[inline]
    pub fn is_adc14ie11_1(&self) -> bool {
        *self == ADC14IE11R::ADC14IE11_1
    }
}
#[doc = "Possible values of the field `ADC14IE12`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE12R {
    #[doc = "Interrupt disabled"]
    ADC14IE12_0,
    #[doc = "Interrupt enabled"]
    ADC14IE12_1,
}
impl ADC14IE12R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE12R::ADC14IE12_0 => false,
            ADC14IE12R::ADC14IE12_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE12R {
        match value {
            false => ADC14IE12R::ADC14IE12_0,
            true => ADC14IE12R::ADC14IE12_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE12_0`"]
    #[inline]
    pub fn is_adc14ie12_0(&self) -> bool {
        *self == ADC14IE12R::ADC14IE12_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE12_1`"]
    #[inline]
    pub fn is_adc14ie12_1(&self) -> bool {
        *self == ADC14IE12R::ADC14IE12_1
    }
}
#[doc = "Possible values of the field `ADC14IE13`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE13R {
    #[doc = "Interrupt disabled"]
    ADC14IE13_0,
    #[doc = "Interrupt enabled"]
    ADC14IE13_1,
}
impl ADC14IE13R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE13R::ADC14IE13_0 => false,
            ADC14IE13R::ADC14IE13_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE13R {
        match value {
            false => ADC14IE13R::ADC14IE13_0,
            true => ADC14IE13R::ADC14IE13_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE13_0`"]
    #[inline]
    pub fn is_adc14ie13_0(&self) -> bool {
        *self == ADC14IE13R::ADC14IE13_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE13_1`"]
    #[inline]
    pub fn is_adc14ie13_1(&self) -> bool {
        *self == ADC14IE13R::ADC14IE13_1
    }
}
#[doc = "Possible values of the field `ADC14IE14`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE14R {
    #[doc = "Interrupt disabled"]
    ADC14IE14_0,
    #[doc = "Interrupt enabled"]
    ADC14IE14_1,
}
impl ADC14IE14R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE14R::ADC14IE14_0 => false,
            ADC14IE14R::ADC14IE14_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE14R {
        match value {
            false => ADC14IE14R::ADC14IE14_0,
            true => ADC14IE14R::ADC14IE14_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE14_0`"]
    #[inline]
    pub fn is_adc14ie14_0(&self) -> bool {
        *self == ADC14IE14R::ADC14IE14_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE14_1`"]
    #[inline]
    pub fn is_adc14ie14_1(&self) -> bool {
        *self == ADC14IE14R::ADC14IE14_1
    }
}
#[doc = "Possible values of the field `ADC14IE15`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE15R {
    #[doc = "Interrupt disabled"]
    ADC14IE15_0,
    #[doc = "Interrupt enabled"]
    ADC14IE15_1,
}
impl ADC14IE15R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE15R::ADC14IE15_0 => false,
            ADC14IE15R::ADC14IE15_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE15R {
        match value {
            false => ADC14IE15R::ADC14IE15_0,
            true => ADC14IE15R::ADC14IE15_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE15_0`"]
    #[inline]
    pub fn is_adc14ie15_0(&self) -> bool {
        *self == ADC14IE15R::ADC14IE15_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE15_1`"]
    #[inline]
    pub fn is_adc14ie15_1(&self) -> bool {
        *self == ADC14IE15R::ADC14IE15_1
    }
}
#[doc = "Possible values of the field `ADC14IE16`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE16R {
    #[doc = "Interrupt disabled"]
    ADC14IE16_0,
    #[doc = "Interrupt enabled"]
    ADC14IE16_1,
}
impl ADC14IE16R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE16R::ADC14IE16_0 => false,
            ADC14IE16R::ADC14IE16_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE16R {
        match value {
            false => ADC14IE16R::ADC14IE16_0,
            true => ADC14IE16R::ADC14IE16_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE16_0`"]
    #[inline]
    pub fn is_adc14ie16_0(&self) -> bool {
        *self == ADC14IE16R::ADC14IE16_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE16_1`"]
    #[inline]
    pub fn is_adc14ie16_1(&self) -> bool {
        *self == ADC14IE16R::ADC14IE16_1
    }
}
#[doc = "Possible values of the field `ADC14IE17`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE17R {
    #[doc = "Interrupt disabled"]
    ADC14IE17_0,
    #[doc = "Interrupt enabled"]
    ADC14IE17_1,
}
impl ADC14IE17R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE17R::ADC14IE17_0 => false,
            ADC14IE17R::ADC14IE17_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE17R {
        match value {
            false => ADC14IE17R::ADC14IE17_0,
            true => ADC14IE17R::ADC14IE17_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE17_0`"]
    #[inline]
    pub fn is_adc14ie17_0(&self) -> bool {
        *self == ADC14IE17R::ADC14IE17_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE17_1`"]
    #[inline]
    pub fn is_adc14ie17_1(&self) -> bool {
        *self == ADC14IE17R::ADC14IE17_1
    }
}
#[doc = "Possible values of the field `ADC14IE19`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE19R {
    #[doc = "Interrupt disabled"]
    ADC14IE19_0,
    #[doc = "Interrupt enabled"]
    ADC14IE19_1,
}
impl ADC14IE19R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE19R::ADC14IE19_0 => false,
            ADC14IE19R::ADC14IE19_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE19R {
        match value {
            false => ADC14IE19R::ADC14IE19_0,
            true => ADC14IE19R::ADC14IE19_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE19_0`"]
    #[inline]
    pub fn is_adc14ie19_0(&self) -> bool {
        *self == ADC14IE19R::ADC14IE19_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE19_1`"]
    #[inline]
    pub fn is_adc14ie19_1(&self) -> bool {
        *self == ADC14IE19R::ADC14IE19_1
    }
}
#[doc = "Possible values of the field `ADC14IE18`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE18R {
    #[doc = "Interrupt disabled"]
    ADC14IE18_0,
    #[doc = "Interrupt enabled"]
    ADC14IE18_1,
}
impl ADC14IE18R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE18R::ADC14IE18_0 => false,
            ADC14IE18R::ADC14IE18_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE18R {
        match value {
            false => ADC14IE18R::ADC14IE18_0,
            true => ADC14IE18R::ADC14IE18_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE18_0`"]
    #[inline]
    pub fn is_adc14ie18_0(&self) -> bool {
        *self == ADC14IE18R::ADC14IE18_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE18_1`"]
    #[inline]
    pub fn is_adc14ie18_1(&self) -> bool {
        *self == ADC14IE18R::ADC14IE18_1
    }
}
#[doc = "Possible values of the field `ADC14IE20`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE20R {
    #[doc = "Interrupt disabled"]
    ADC14IE20_0,
    #[doc = "Interrupt enabled"]
    ADC14IE20_1,
}
impl ADC14IE20R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE20R::ADC14IE20_0 => false,
            ADC14IE20R::ADC14IE20_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE20R {
        match value {
            false => ADC14IE20R::ADC14IE20_0,
            true => ADC14IE20R::ADC14IE20_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE20_0`"]
    #[inline]
    pub fn is_adc14ie20_0(&self) -> bool {
        *self == ADC14IE20R::ADC14IE20_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE20_1`"]
    #[inline]
    pub fn is_adc14ie20_1(&self) -> bool {
        *self == ADC14IE20R::ADC14IE20_1
    }
}
#[doc = "Possible values of the field `ADC14IE21`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE21R {
    #[doc = "Interrupt disabled"]
    ADC14IE21_0,
    #[doc = "Interrupt enabled"]
    ADC14IE21_1,
}
impl ADC14IE21R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE21R::ADC14IE21_0 => false,
            ADC14IE21R::ADC14IE21_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE21R {
        match value {
            false => ADC14IE21R::ADC14IE21_0,
            true => ADC14IE21R::ADC14IE21_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE21_0`"]
    #[inline]
    pub fn is_adc14ie21_0(&self) -> bool {
        *self == ADC14IE21R::ADC14IE21_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE21_1`"]
    #[inline]
    pub fn is_adc14ie21_1(&self) -> bool {
        *self == ADC14IE21R::ADC14IE21_1
    }
}
#[doc = "Possible values of the field `ADC14IE22`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE22R {
    #[doc = "Interrupt disabled"]
    ADC14IE22_0,
    #[doc = "Interrupt enabled"]
    ADC14IE22_1,
}
impl ADC14IE22R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE22R::ADC14IE22_0 => false,
            ADC14IE22R::ADC14IE22_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE22R {
        match value {
            false => ADC14IE22R::ADC14IE22_0,
            true => ADC14IE22R::ADC14IE22_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE22_0`"]
    #[inline]
    pub fn is_adc14ie22_0(&self) -> bool {
        *self == ADC14IE22R::ADC14IE22_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE22_1`"]
    #[inline]
    pub fn is_adc14ie22_1(&self) -> bool {
        *self == ADC14IE22R::ADC14IE22_1
    }
}
#[doc = "Possible values of the field `ADC14IE23`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE23R {
    #[doc = "Interrupt disabled"]
    ADC14IE23_0,
    #[doc = "Interrupt enabled"]
    ADC14IE23_1,
}
impl ADC14IE23R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE23R::ADC14IE23_0 => false,
            ADC14IE23R::ADC14IE23_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE23R {
        match value {
            false => ADC14IE23R::ADC14IE23_0,
            true => ADC14IE23R::ADC14IE23_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE23_0`"]
    #[inline]
    pub fn is_adc14ie23_0(&self) -> bool {
        *self == ADC14IE23R::ADC14IE23_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE23_1`"]
    #[inline]
    pub fn is_adc14ie23_1(&self) -> bool {
        *self == ADC14IE23R::ADC14IE23_1
    }
}
#[doc = "Possible values of the field `ADC14IE24`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE24R {
    #[doc = "Interrupt disabled"]
    ADC14IE24_0,
    #[doc = "Interrupt enabled"]
    ADC14IE24_1,
}
impl ADC14IE24R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE24R::ADC14IE24_0 => false,
            ADC14IE24R::ADC14IE24_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE24R {
        match value {
            false => ADC14IE24R::ADC14IE24_0,
            true => ADC14IE24R::ADC14IE24_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE24_0`"]
    #[inline]
    pub fn is_adc14ie24_0(&self) -> bool {
        *self == ADC14IE24R::ADC14IE24_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE24_1`"]
    #[inline]
    pub fn is_adc14ie24_1(&self) -> bool {
        *self == ADC14IE24R::ADC14IE24_1
    }
}
#[doc = "Possible values of the field `ADC14IE25`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE25R {
    #[doc = "Interrupt disabled"]
    ADC14IE25_0,
    #[doc = "Interrupt enabled"]
    ADC14IE25_1,
}
impl ADC14IE25R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE25R::ADC14IE25_0 => false,
            ADC14IE25R::ADC14IE25_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE25R {
        match value {
            false => ADC14IE25R::ADC14IE25_0,
            true => ADC14IE25R::ADC14IE25_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE25_0`"]
    #[inline]
    pub fn is_adc14ie25_0(&self) -> bool {
        *self == ADC14IE25R::ADC14IE25_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE25_1`"]
    #[inline]
    pub fn is_adc14ie25_1(&self) -> bool {
        *self == ADC14IE25R::ADC14IE25_1
    }
}
#[doc = "Possible values of the field `ADC14IE26`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE26R {
    #[doc = "Interrupt disabled"]
    ADC14IE26_0,
    #[doc = "Interrupt enabled"]
    ADC14IE26_1,
}
impl ADC14IE26R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE26R::ADC14IE26_0 => false,
            ADC14IE26R::ADC14IE26_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE26R {
        match value {
            false => ADC14IE26R::ADC14IE26_0,
            true => ADC14IE26R::ADC14IE26_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE26_0`"]
    #[inline]
    pub fn is_adc14ie26_0(&self) -> bool {
        *self == ADC14IE26R::ADC14IE26_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE26_1`"]
    #[inline]
    pub fn is_adc14ie26_1(&self) -> bool {
        *self == ADC14IE26R::ADC14IE26_1
    }
}
#[doc = "Possible values of the field `ADC14IE27`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE27R {
    #[doc = "Interrupt disabled"]
    ADC14IE27_0,
    #[doc = "Interrupt enabled"]
    ADC14IE27_1,
}
impl ADC14IE27R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE27R::ADC14IE27_0 => false,
            ADC14IE27R::ADC14IE27_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE27R {
        match value {
            false => ADC14IE27R::ADC14IE27_0,
            true => ADC14IE27R::ADC14IE27_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE27_0`"]
    #[inline]
    pub fn is_adc14ie27_0(&self) -> bool {
        *self == ADC14IE27R::ADC14IE27_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE27_1`"]
    #[inline]
    pub fn is_adc14ie27_1(&self) -> bool {
        *self == ADC14IE27R::ADC14IE27_1
    }
}
#[doc = "Possible values of the field `ADC14IE28`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE28R {
    #[doc = "Interrupt disabled"]
    ADC14IE28_0,
    #[doc = "Interrupt enabled"]
    ADC14IE28_1,
}
impl ADC14IE28R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE28R::ADC14IE28_0 => false,
            ADC14IE28R::ADC14IE28_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE28R {
        match value {
            false => ADC14IE28R::ADC14IE28_0,
            true => ADC14IE28R::ADC14IE28_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE28_0`"]
    #[inline]
    pub fn is_adc14ie28_0(&self) -> bool {
        *self == ADC14IE28R::ADC14IE28_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE28_1`"]
    #[inline]
    pub fn is_adc14ie28_1(&self) -> bool {
        *self == ADC14IE28R::ADC14IE28_1
    }
}
#[doc = "Possible values of the field `ADC14IE29`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE29R {
    #[doc = "Interrupt disabled"]
    ADC14IE29_0,
    #[doc = "Interrupt enabled"]
    ADC14IE29_1,
}
impl ADC14IE29R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE29R::ADC14IE29_0 => false,
            ADC14IE29R::ADC14IE29_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE29R {
        match value {
            false => ADC14IE29R::ADC14IE29_0,
            true => ADC14IE29R::ADC14IE29_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE29_0`"]
    #[inline]
    pub fn is_adc14ie29_0(&self) -> bool {
        *self == ADC14IE29R::ADC14IE29_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE29_1`"]
    #[inline]
    pub fn is_adc14ie29_1(&self) -> bool {
        *self == ADC14IE29R::ADC14IE29_1
    }
}
#[doc = "Possible values of the field `ADC14IE30`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE30R {
    #[doc = "Interrupt disabled"]
    ADC14IE30_0,
    #[doc = "Interrupt enabled"]
    ADC14IE30_1,
}
impl ADC14IE30R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE30R::ADC14IE30_0 => false,
            ADC14IE30R::ADC14IE30_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE30R {
        match value {
            false => ADC14IE30R::ADC14IE30_0,
            true => ADC14IE30R::ADC14IE30_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE30_0`"]
    #[inline]
    pub fn is_adc14ie30_0(&self) -> bool {
        *self == ADC14IE30R::ADC14IE30_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE30_1`"]
    #[inline]
    pub fn is_adc14ie30_1(&self) -> bool {
        *self == ADC14IE30R::ADC14IE30_1
    }
}
#[doc = "Possible values of the field `ADC14IE31`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ADC14IE31R {
    #[doc = "Interrupt disabled"]
    ADC14IE31_0,
    #[doc = "Interrupt enabled"]
    ADC14IE31_1,
}
impl ADC14IE31R {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ADC14IE31R::ADC14IE31_0 => false,
            ADC14IE31R::ADC14IE31_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ADC14IE31R {
        match value {
            false => ADC14IE31R::ADC14IE31_0,
            true => ADC14IE31R::ADC14IE31_1,
        }
    }
    #[doc = "Checks if the value of the field is `ADC14IE31_0`"]
    #[inline]
    pub fn is_adc14ie31_0(&self) -> bool {
        *self == ADC14IE31R::ADC14IE31_0
    }
    #[doc = "Checks if the value of the field is `ADC14IE31_1`"]
    #[inline]
    pub fn is_adc14ie31_1(&self) -> bool {
        *self == ADC14IE31R::ADC14IE31_1
    }
}
#[doc = "Values that can be written to the field `ADC14IE0`"]
pub enum ADC14IE0W {
    #[doc = "Interrupt disabled"]
    ADC14IE0_0,
    #[doc = "Interrupt enabled"]
    ADC14IE0_1,
}
impl ADC14IE0W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE0W::ADC14IE0_0 => false,
            ADC14IE0W::ADC14IE0_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE0W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE0W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE0W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie0_0(self) -> &'a mut W {
        self.variant(ADC14IE0W::ADC14IE0_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie0_1(self) -> &'a mut W {
        self.variant(ADC14IE0W::ADC14IE0_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 0;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE1`"]
pub enum ADC14IE1W {
    #[doc = "Interrupt disabled"]
    ADC14IE1_0,
    #[doc = "Interrupt enabled"]
    ADC14IE1_1,
}
impl ADC14IE1W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE1W::ADC14IE1_0 => false,
            ADC14IE1W::ADC14IE1_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE1W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE1W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE1W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie1_0(self) -> &'a mut W {
        self.variant(ADC14IE1W::ADC14IE1_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie1_1(self) -> &'a mut W {
        self.variant(ADC14IE1W::ADC14IE1_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 1;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE2`"]
pub enum ADC14IE2W {
    #[doc = "Interrupt disabled"]
    ADC14IE2_0,
    #[doc = "Interrupt enabled"]
    ADC14IE2_1,
}
impl ADC14IE2W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE2W::ADC14IE2_0 => false,
            ADC14IE2W::ADC14IE2_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE2W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE2W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE2W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie2_0(self) -> &'a mut W {
        self.variant(ADC14IE2W::ADC14IE2_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie2_1(self) -> &'a mut W {
        self.variant(ADC14IE2W::ADC14IE2_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 2;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE3`"]
pub enum ADC14IE3W {
    #[doc = "Interrupt disabled"]
    ADC14IE3_0,
    #[doc = "Interrupt enabled"]
    ADC14IE3_1,
}
impl ADC14IE3W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE3W::ADC14IE3_0 => false,
            ADC14IE3W::ADC14IE3_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE3W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE3W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE3W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie3_0(self) -> &'a mut W {
        self.variant(ADC14IE3W::ADC14IE3_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie3_1(self) -> &'a mut W {
        self.variant(ADC14IE3W::ADC14IE3_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 3;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE4`"]
pub enum ADC14IE4W {
    #[doc = "Interrupt disabled"]
    ADC14IE4_0,
    #[doc = "Interrupt enabled"]
    ADC14IE4_1,
}
impl ADC14IE4W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE4W::ADC14IE4_0 => false,
            ADC14IE4W::ADC14IE4_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE4W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE4W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE4W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie4_0(self) -> &'a mut W {
        self.variant(ADC14IE4W::ADC14IE4_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie4_1(self) -> &'a mut W {
        self.variant(ADC14IE4W::ADC14IE4_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 4;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE5`"]
pub enum ADC14IE5W {
    #[doc = "Interrupt disabled"]
    ADC14IE5_0,
    #[doc = "Interrupt enabled"]
    ADC14IE5_1,
}
impl ADC14IE5W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE5W::ADC14IE5_0 => false,
            ADC14IE5W::ADC14IE5_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE5W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE5W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE5W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie5_0(self) -> &'a mut W {
        self.variant(ADC14IE5W::ADC14IE5_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie5_1(self) -> &'a mut W {
        self.variant(ADC14IE5W::ADC14IE5_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 5;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE6`"]
pub enum ADC14IE6W {
    #[doc = "Interrupt disabled"]
    ADC14IE6_0,
    #[doc = "Interrupt enabled"]
    ADC14IE6_1,
}
impl ADC14IE6W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE6W::ADC14IE6_0 => false,
            ADC14IE6W::ADC14IE6_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE6W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE6W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE6W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie6_0(self) -> &'a mut W {
        self.variant(ADC14IE6W::ADC14IE6_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie6_1(self) -> &'a mut W {
        self.variant(ADC14IE6W::ADC14IE6_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 6;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE7`"]
pub enum ADC14IE7W {
    #[doc = "Interrupt disabled"]
    ADC14IE7_0,
    #[doc = "Interrupt enabled"]
    ADC14IE7_1,
}
impl ADC14IE7W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE7W::ADC14IE7_0 => false,
            ADC14IE7W::ADC14IE7_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE7W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE7W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE7W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie7_0(self) -> &'a mut W {
        self.variant(ADC14IE7W::ADC14IE7_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie7_1(self) -> &'a mut W {
        self.variant(ADC14IE7W::ADC14IE7_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 7;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE8`"]
pub enum ADC14IE8W {
    #[doc = "Interrupt disabled"]
    ADC14IE8_0,
    #[doc = "Interrupt enabled"]
    ADC14IE8_1,
}
impl ADC14IE8W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE8W::ADC14IE8_0 => false,
            ADC14IE8W::ADC14IE8_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE8W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE8W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE8W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie8_0(self) -> &'a mut W {
        self.variant(ADC14IE8W::ADC14IE8_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie8_1(self) -> &'a mut W {
        self.variant(ADC14IE8W::ADC14IE8_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 8;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE9`"]
pub enum ADC14IE9W {
    #[doc = "Interrupt disabled"]
    ADC14IE9_0,
    #[doc = "Interrupt enabled"]
    ADC14IE9_1,
}
impl ADC14IE9W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE9W::ADC14IE9_0 => false,
            ADC14IE9W::ADC14IE9_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE9W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE9W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE9W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie9_0(self) -> &'a mut W {
        self.variant(ADC14IE9W::ADC14IE9_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie9_1(self) -> &'a mut W {
        self.variant(ADC14IE9W::ADC14IE9_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 9;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE10`"]
pub enum ADC14IE10W {
    #[doc = "Interrupt disabled"]
    ADC14IE10_0,
    #[doc = "Interrupt enabled"]
    ADC14IE10_1,
}
impl ADC14IE10W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE10W::ADC14IE10_0 => false,
            ADC14IE10W::ADC14IE10_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE10W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE10W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE10W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie10_0(self) -> &'a mut W {
        self.variant(ADC14IE10W::ADC14IE10_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie10_1(self) -> &'a mut W {
        self.variant(ADC14IE10W::ADC14IE10_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 10;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE11`"]
pub enum ADC14IE11W {
    #[doc = "Interrupt disabled"]
    ADC14IE11_0,
    #[doc = "Interrupt enabled"]
    ADC14IE11_1,
}
impl ADC14IE11W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE11W::ADC14IE11_0 => false,
            ADC14IE11W::ADC14IE11_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE11W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE11W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE11W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie11_0(self) -> &'a mut W {
        self.variant(ADC14IE11W::ADC14IE11_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie11_1(self) -> &'a mut W {
        self.variant(ADC14IE11W::ADC14IE11_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 11;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE12`"]
pub enum ADC14IE12W {
    #[doc = "Interrupt disabled"]
    ADC14IE12_0,
    #[doc = "Interrupt enabled"]
    ADC14IE12_1,
}
impl ADC14IE12W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE12W::ADC14IE12_0 => false,
            ADC14IE12W::ADC14IE12_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE12W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE12W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE12W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie12_0(self) -> &'a mut W {
        self.variant(ADC14IE12W::ADC14IE12_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie12_1(self) -> &'a mut W {
        self.variant(ADC14IE12W::ADC14IE12_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 12;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE13`"]
pub enum ADC14IE13W {
    #[doc = "Interrupt disabled"]
    ADC14IE13_0,
    #[doc = "Interrupt enabled"]
    ADC14IE13_1,
}
impl ADC14IE13W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE13W::ADC14IE13_0 => false,
            ADC14IE13W::ADC14IE13_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE13W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE13W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE13W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie13_0(self) -> &'a mut W {
        self.variant(ADC14IE13W::ADC14IE13_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie13_1(self) -> &'a mut W {
        self.variant(ADC14IE13W::ADC14IE13_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 13;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE14`"]
pub enum ADC14IE14W {
    #[doc = "Interrupt disabled"]
    ADC14IE14_0,
    #[doc = "Interrupt enabled"]
    ADC14IE14_1,
}
impl ADC14IE14W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE14W::ADC14IE14_0 => false,
            ADC14IE14W::ADC14IE14_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE14W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE14W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE14W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie14_0(self) -> &'a mut W {
        self.variant(ADC14IE14W::ADC14IE14_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie14_1(self) -> &'a mut W {
        self.variant(ADC14IE14W::ADC14IE14_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 14;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE15`"]
pub enum ADC14IE15W {
    #[doc = "Interrupt disabled"]
    ADC14IE15_0,
    #[doc = "Interrupt enabled"]
    ADC14IE15_1,
}
impl ADC14IE15W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE15W::ADC14IE15_0 => false,
            ADC14IE15W::ADC14IE15_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE15W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE15W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE15W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie15_0(self) -> &'a mut W {
        self.variant(ADC14IE15W::ADC14IE15_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie15_1(self) -> &'a mut W {
        self.variant(ADC14IE15W::ADC14IE15_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 15;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE16`"]
pub enum ADC14IE16W {
    #[doc = "Interrupt disabled"]
    ADC14IE16_0,
    #[doc = "Interrupt enabled"]
    ADC14IE16_1,
}
impl ADC14IE16W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE16W::ADC14IE16_0 => false,
            ADC14IE16W::ADC14IE16_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE16W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE16W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE16W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie16_0(self) -> &'a mut W {
        self.variant(ADC14IE16W::ADC14IE16_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie16_1(self) -> &'a mut W {
        self.variant(ADC14IE16W::ADC14IE16_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 16;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE17`"]
pub enum ADC14IE17W {
    #[doc = "Interrupt disabled"]
    ADC14IE17_0,
    #[doc = "Interrupt enabled"]
    ADC14IE17_1,
}
impl ADC14IE17W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE17W::ADC14IE17_0 => false,
            ADC14IE17W::ADC14IE17_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE17W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE17W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE17W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie17_0(self) -> &'a mut W {
        self.variant(ADC14IE17W::ADC14IE17_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie17_1(self) -> &'a mut W {
        self.variant(ADC14IE17W::ADC14IE17_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 17;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE19`"]
pub enum ADC14IE19W {
    #[doc = "Interrupt disabled"]
    ADC14IE19_0,
    #[doc = "Interrupt enabled"]
    ADC14IE19_1,
}
impl ADC14IE19W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE19W::ADC14IE19_0 => false,
            ADC14IE19W::ADC14IE19_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE19W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE19W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE19W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie19_0(self) -> &'a mut W {
        self.variant(ADC14IE19W::ADC14IE19_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie19_1(self) -> &'a mut W {
        self.variant(ADC14IE19W::ADC14IE19_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 19;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE18`"]
pub enum ADC14IE18W {
    #[doc = "Interrupt disabled"]
    ADC14IE18_0,
    #[doc = "Interrupt enabled"]
    ADC14IE18_1,
}
impl ADC14IE18W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE18W::ADC14IE18_0 => false,
            ADC14IE18W::ADC14IE18_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE18W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE18W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE18W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie18_0(self) -> &'a mut W {
        self.variant(ADC14IE18W::ADC14IE18_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie18_1(self) -> &'a mut W {
        self.variant(ADC14IE18W::ADC14IE18_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 18;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE20`"]
pub enum ADC14IE20W {
    #[doc = "Interrupt disabled"]
    ADC14IE20_0,
    #[doc = "Interrupt enabled"]
    ADC14IE20_1,
}
impl ADC14IE20W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE20W::ADC14IE20_0 => false,
            ADC14IE20W::ADC14IE20_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE20W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE20W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE20W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie20_0(self) -> &'a mut W {
        self.variant(ADC14IE20W::ADC14IE20_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie20_1(self) -> &'a mut W {
        self.variant(ADC14IE20W::ADC14IE20_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 20;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE21`"]
pub enum ADC14IE21W {
    #[doc = "Interrupt disabled"]
    ADC14IE21_0,
    #[doc = "Interrupt enabled"]
    ADC14IE21_1,
}
impl ADC14IE21W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE21W::ADC14IE21_0 => false,
            ADC14IE21W::ADC14IE21_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE21W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE21W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE21W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie21_0(self) -> &'a mut W {
        self.variant(ADC14IE21W::ADC14IE21_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie21_1(self) -> &'a mut W {
        self.variant(ADC14IE21W::ADC14IE21_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 21;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE22`"]
pub enum ADC14IE22W {
    #[doc = "Interrupt disabled"]
    ADC14IE22_0,
    #[doc = "Interrupt enabled"]
    ADC14IE22_1,
}
impl ADC14IE22W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE22W::ADC14IE22_0 => false,
            ADC14IE22W::ADC14IE22_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE22W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE22W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE22W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie22_0(self) -> &'a mut W {
        self.variant(ADC14IE22W::ADC14IE22_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie22_1(self) -> &'a mut W {
        self.variant(ADC14IE22W::ADC14IE22_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 22;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE23`"]
pub enum ADC14IE23W {
    #[doc = "Interrupt disabled"]
    ADC14IE23_0,
    #[doc = "Interrupt enabled"]
    ADC14IE23_1,
}
impl ADC14IE23W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE23W::ADC14IE23_0 => false,
            ADC14IE23W::ADC14IE23_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE23W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE23W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE23W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie23_0(self) -> &'a mut W {
        self.variant(ADC14IE23W::ADC14IE23_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie23_1(self) -> &'a mut W {
        self.variant(ADC14IE23W::ADC14IE23_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 23;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE24`"]
pub enum ADC14IE24W {
    #[doc = "Interrupt disabled"]
    ADC14IE24_0,
    #[doc = "Interrupt enabled"]
    ADC14IE24_1,
}
impl ADC14IE24W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE24W::ADC14IE24_0 => false,
            ADC14IE24W::ADC14IE24_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE24W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE24W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE24W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie24_0(self) -> &'a mut W {
        self.variant(ADC14IE24W::ADC14IE24_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie24_1(self) -> &'a mut W {
        self.variant(ADC14IE24W::ADC14IE24_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 24;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE25`"]
pub enum ADC14IE25W {
    #[doc = "Interrupt disabled"]
    ADC14IE25_0,
    #[doc = "Interrupt enabled"]
    ADC14IE25_1,
}
impl ADC14IE25W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE25W::ADC14IE25_0 => false,
            ADC14IE25W::ADC14IE25_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE25W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE25W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE25W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie25_0(self) -> &'a mut W {
        self.variant(ADC14IE25W::ADC14IE25_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie25_1(self) -> &'a mut W {
        self.variant(ADC14IE25W::ADC14IE25_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 25;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE26`"]
pub enum ADC14IE26W {
    #[doc = "Interrupt disabled"]
    ADC14IE26_0,
    #[doc = "Interrupt enabled"]
    ADC14IE26_1,
}
impl ADC14IE26W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE26W::ADC14IE26_0 => false,
            ADC14IE26W::ADC14IE26_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE26W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE26W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE26W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie26_0(self) -> &'a mut W {
        self.variant(ADC14IE26W::ADC14IE26_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie26_1(self) -> &'a mut W {
        self.variant(ADC14IE26W::ADC14IE26_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 26;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE27`"]
pub enum ADC14IE27W {
    #[doc = "Interrupt disabled"]
    ADC14IE27_0,
    #[doc = "Interrupt enabled"]
    ADC14IE27_1,
}
impl ADC14IE27W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE27W::ADC14IE27_0 => false,
            ADC14IE27W::ADC14IE27_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE27W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE27W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE27W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie27_0(self) -> &'a mut W {
        self.variant(ADC14IE27W::ADC14IE27_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie27_1(self) -> &'a mut W {
        self.variant(ADC14IE27W::ADC14IE27_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 27;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE28`"]
pub enum ADC14IE28W {
    #[doc = "Interrupt disabled"]
    ADC14IE28_0,
    #[doc = "Interrupt enabled"]
    ADC14IE28_1,
}
impl ADC14IE28W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE28W::ADC14IE28_0 => false,
            ADC14IE28W::ADC14IE28_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE28W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE28W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE28W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie28_0(self) -> &'a mut W {
        self.variant(ADC14IE28W::ADC14IE28_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie28_1(self) -> &'a mut W {
        self.variant(ADC14IE28W::ADC14IE28_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 28;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE29`"]
pub enum ADC14IE29W {
    #[doc = "Interrupt disabled"]
    ADC14IE29_0,
    #[doc = "Interrupt enabled"]
    ADC14IE29_1,
}
impl ADC14IE29W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE29W::ADC14IE29_0 => false,
            ADC14IE29W::ADC14IE29_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE29W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE29W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE29W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie29_0(self) -> &'a mut W {
        self.variant(ADC14IE29W::ADC14IE29_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie29_1(self) -> &'a mut W {
        self.variant(ADC14IE29W::ADC14IE29_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 29;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE30`"]
pub enum ADC14IE30W {
    #[doc = "Interrupt disabled"]
    ADC14IE30_0,
    #[doc = "Interrupt enabled"]
    ADC14IE30_1,
}
impl ADC14IE30W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE30W::ADC14IE30_0 => false,
            ADC14IE30W::ADC14IE30_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE30W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE30W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE30W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie30_0(self) -> &'a mut W {
        self.variant(ADC14IE30W::ADC14IE30_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie30_1(self) -> &'a mut W {
        self.variant(ADC14IE30W::ADC14IE30_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 30;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `ADC14IE31`"]
pub enum ADC14IE31W {
    #[doc = "Interrupt disabled"]
    ADC14IE31_0,
    #[doc = "Interrupt enabled"]
    ADC14IE31_1,
}
impl ADC14IE31W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            ADC14IE31W::ADC14IE31_0 => false,
            ADC14IE31W::ADC14IE31_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _ADC14IE31W<'a> {
    w: &'a mut W,
}
impl<'a> _ADC14IE31W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: ADC14IE31W) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "Interrupt disabled"]
    #[inline]
    pub fn adc14ie31_0(self) -> &'a mut W {
        self.variant(ADC14IE31W::ADC14IE31_0)
    }
    #[doc = "Interrupt enabled"]
    #[inline]
    pub fn adc14ie31_1(self) -> &'a mut W {
        self.variant(ADC14IE31W::ADC14IE31_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 31;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
impl R {
    #[doc = r" Value of the register as raw bits"]
    #[inline]
    pub fn bits(&self) -> u32 {
        self.bits
    }
    #[doc = "Bit 0 - Interrupt enable"]
    #[inline]
    pub fn adc14ie0(&self) -> ADC14IE0R {
        ADC14IE0R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 0;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 1 - Interrupt enable"]
    #[inline]
    pub fn adc14ie1(&self) -> ADC14IE1R {
        ADC14IE1R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 1;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 2 - Interrupt enable"]
    #[inline]
    pub fn adc14ie2(&self) -> ADC14IE2R {
        ADC14IE2R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 2;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 3 - Interrupt enable"]
    #[inline]
    pub fn adc14ie3(&self) -> ADC14IE3R {
        ADC14IE3R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 3;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 4 - Interrupt enable"]
    #[inline]
    pub fn adc14ie4(&self) -> ADC14IE4R {
        ADC14IE4R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 4;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 5 - Interrupt enable"]
    #[inline]
    pub fn adc14ie5(&self) -> ADC14IE5R {
        ADC14IE5R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 5;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 6 - Interrupt enable"]
    #[inline]
    pub fn adc14ie6(&self) -> ADC14IE6R {
        ADC14IE6R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 6;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 7 - Interrupt enable"]
    #[inline]
    pub fn adc14ie7(&self) -> ADC14IE7R {
        ADC14IE7R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 7;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 8 - Interrupt enable"]
    #[inline]
    pub fn adc14ie8(&self) -> ADC14IE8R {
        ADC14IE8R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 8;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 9 - Interrupt enable"]
    #[inline]
    pub fn adc14ie9(&self) -> ADC14IE9R {
        ADC14IE9R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 9;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 10 - Interrupt enable"]
    #[inline]
    pub fn adc14ie10(&self) -> ADC14IE10R {
        ADC14IE10R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 10;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 11 - Interrupt enable"]
    #[inline]
    pub fn adc14ie11(&self) -> ADC14IE11R {
        ADC14IE11R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 11;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 12 - Interrupt enable"]
    #[inline]
    pub fn adc14ie12(&self) -> ADC14IE12R {
        ADC14IE12R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 12;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 13 - Interrupt enable"]
    #[inline]
    pub fn adc14ie13(&self) -> ADC14IE13R {
        ADC14IE13R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 13;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 14 - Interrupt enable"]
    #[inline]
    pub fn adc14ie14(&self) -> ADC14IE14R {
        ADC14IE14R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 14;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 15 - Interrupt enable"]
    #[inline]
    pub fn adc14ie15(&self) -> ADC14IE15R {
        ADC14IE15R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 15;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 16 - Interrupt enable"]
    #[inline]
    pub fn adc14ie16(&self) -> ADC14IE16R {
        ADC14IE16R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 16;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 17 - Interrupt enable"]
    #[inline]
    pub fn adc14ie17(&self) -> ADC14IE17R {
        ADC14IE17R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 17;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 19 - Interrupt enable"]
    #[inline]
    pub fn adc14ie19(&self) -> ADC14IE19R {
        ADC14IE19R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 19;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 18 - Interrupt enable"]
    #[inline]
    pub fn adc14ie18(&self) -> ADC14IE18R {
        ADC14IE18R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 18;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 20 - Interrupt enable"]
    #[inline]
    pub fn adc14ie20(&self) -> ADC14IE20R {
        ADC14IE20R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 20;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 21 - Interrupt enable"]
    #[inline]
    pub fn adc14ie21(&self) -> ADC14IE21R {
        ADC14IE21R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 21;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 22 - Interrupt enable"]
    #[inline]
    pub fn adc14ie22(&self) -> ADC14IE22R {
        ADC14IE22R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 22;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 23 - Interrupt enable"]
    #[inline]
    pub fn adc14ie23(&self) -> ADC14IE23R {
        ADC14IE23R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 23;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 24 - Interrupt enable"]
    #[inline]
    pub fn adc14ie24(&self) -> ADC14IE24R {
        ADC14IE24R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 24;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 25 - Interrupt enable"]
    #[inline]
    pub fn adc14ie25(&self) -> ADC14IE25R {
        ADC14IE25R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 25;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 26 - Interrupt enable"]
    #[inline]
    pub fn adc14ie26(&self) -> ADC14IE26R {
        ADC14IE26R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 26;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 27 - Interrupt enable"]
    #[inline]
    pub fn adc14ie27(&self) -> ADC14IE27R {
        ADC14IE27R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 27;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 28 - Interrupt enable"]
    #[inline]
    pub fn adc14ie28(&self) -> ADC14IE28R {
        ADC14IE28R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 28;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 29 - Interrupt enable"]
    #[inline]
    pub fn adc14ie29(&self) -> ADC14IE29R {
        ADC14IE29R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 29;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 30 - Interrupt enable"]
    #[inline]
    pub fn adc14ie30(&self) -> ADC14IE30R {
        ADC14IE30R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 30;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 31 - Interrupt enable"]
    #[inline]
    pub fn adc14ie31(&self) -> ADC14IE31R {
        ADC14IE31R::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 31;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
}
impl W {
    #[doc = r" Reset value of the register"]
    #[inline]
    pub fn reset_value() -> W {
        W { bits: 0 }
    }
    #[doc = r" Writes raw bits to the register"]
    #[inline]
    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
        self.bits = bits;
        self
    }
    #[doc = "Bit 0 - Interrupt enable"]
    #[inline]
    pub fn adc14ie0(&mut self) -> _ADC14IE0W {
        _ADC14IE0W { w: self }
    }
    #[doc = "Bit 1 - Interrupt enable"]
    #[inline]
    pub fn adc14ie1(&mut self) -> _ADC14IE1W {
        _ADC14IE1W { w: self }
    }
    #[doc = "Bit 2 - Interrupt enable"]
    #[inline]
    pub fn adc14ie2(&mut self) -> _ADC14IE2W {
        _ADC14IE2W { w: self }
    }
    #[doc = "Bit 3 - Interrupt enable"]
    #[inline]
    pub fn adc14ie3(&mut self) -> _ADC14IE3W {
        _ADC14IE3W { w: self }
    }
    #[doc = "Bit 4 - Interrupt enable"]
    #[inline]
    pub fn adc14ie4(&mut self) -> _ADC14IE4W {
        _ADC14IE4W { w: self }
    }
    #[doc = "Bit 5 - Interrupt enable"]
    #[inline]
    pub fn adc14ie5(&mut self) -> _ADC14IE5W {
        _ADC14IE5W { w: self }
    }
    #[doc = "Bit 6 - Interrupt enable"]
    #[inline]
    pub fn adc14ie6(&mut self) -> _ADC14IE6W {
        _ADC14IE6W { w: self }
    }
    #[doc = "Bit 7 - Interrupt enable"]
    #[inline]
    pub fn adc14ie7(&mut self) -> _ADC14IE7W {
        _ADC14IE7W { w: self }
    }
    #[doc = "Bit 8 - Interrupt enable"]
    #[inline]
    pub fn adc14ie8(&mut self) -> _ADC14IE8W {
        _ADC14IE8W { w: self }
    }
    #[doc = "Bit 9 - Interrupt enable"]
    #[inline]
    pub fn adc14ie9(&mut self) -> _ADC14IE9W {
        _ADC14IE9W { w: self }
    }
    #[doc = "Bit 10 - Interrupt enable"]
    #[inline]
    pub fn adc14ie10(&mut self) -> _ADC14IE10W {
        _ADC14IE10W { w: self }
    }
    #[doc = "Bit 11 - Interrupt enable"]
    #[inline]
    pub fn adc14ie11(&mut self) -> _ADC14IE11W {
        _ADC14IE11W { w: self }
    }
    #[doc = "Bit 12 - Interrupt enable"]
    #[inline]
    pub fn adc14ie12(&mut self) -> _ADC14IE12W {
        _ADC14IE12W { w: self }
    }
    #[doc = "Bit 13 - Interrupt enable"]
    #[inline]
    pub fn adc14ie13(&mut self) -> _ADC14IE13W {
        _ADC14IE13W { w: self }
    }
    #[doc = "Bit 14 - Interrupt enable"]
    #[inline]
    pub fn adc14ie14(&mut self) -> _ADC14IE14W {
        _ADC14IE14W { w: self }
    }
    #[doc = "Bit 15 - Interrupt enable"]
    #[inline]
    pub fn adc14ie15(&mut self) -> _ADC14IE15W {
        _ADC14IE15W { w: self }
    }
    #[doc = "Bit 16 - Interrupt enable"]
    #[inline]
    pub fn adc14ie16(&mut self) -> _ADC14IE16W {
        _ADC14IE16W { w: self }
    }
    #[doc = "Bit 17 - Interrupt enable"]
    #[inline]
    pub fn adc14ie17(&mut self) -> _ADC14IE17W {
        _ADC14IE17W { w: self }
    }
    #[doc = "Bit 19 - Interrupt enable"]
    #[inline]
    pub fn adc14ie19(&mut self) -> _ADC14IE19W {
        _ADC14IE19W { w: self }
    }
    #[doc = "Bit 18 - Interrupt enable"]
    #[inline]
    pub fn adc14ie18(&mut self) -> _ADC14IE18W {
        _ADC14IE18W { w: self }
    }
    #[doc = "Bit 20 - Interrupt enable"]
    #[inline]
    pub fn adc14ie20(&mut self) -> _ADC14IE20W {
        _ADC14IE20W { w: self }
    }
    #[doc = "Bit 21 - Interrupt enable"]
    #[inline]
    pub fn adc14ie21(&mut self) -> _ADC14IE21W {
        _ADC14IE21W { w: self }
    }
    #[doc = "Bit 22 - Interrupt enable"]
    #[inline]
    pub fn adc14ie22(&mut self) -> _ADC14IE22W {
        _ADC14IE22W { w: self }
    }
    #[doc = "Bit 23 - Interrupt enable"]
    #[inline]
    pub fn adc14ie23(&mut self) -> _ADC14IE23W {
        _ADC14IE23W { w: self }
    }
    #[doc = "Bit 24 - Interrupt enable"]
    #[inline]
    pub fn adc14ie24(&mut self) -> _ADC14IE24W {
        _ADC14IE24W { w: self }
    }
    #[doc = "Bit 25 - Interrupt enable"]
    #[inline]
    pub fn adc14ie25(&mut self) -> _ADC14IE25W {
        _ADC14IE25W { w: self }
    }
    #[doc = "Bit 26 - Interrupt enable"]
    #[inline]
    pub fn adc14ie26(&mut self) -> _ADC14IE26W {
        _ADC14IE26W { w: self }
    }
    #[doc = "Bit 27 - Interrupt enable"]
    #[inline]
    pub fn adc14ie27(&mut self) -> _ADC14IE27W {
        _ADC14IE27W { w: self }
    }
    #[doc = "Bit 28 - Interrupt enable"]
    #[inline]
    pub fn adc14ie28(&mut self) -> _ADC14IE28W {
        _ADC14IE28W { w: self }
    }
    #[doc = "Bit 29 - Interrupt enable"]
    #[inline]
    pub fn adc14ie29(&mut self) -> _ADC14IE29W {
        _ADC14IE29W { w: self }
    }
    #[doc = "Bit 30 - Interrupt enable"]
    #[inline]
    pub fn adc14ie30(&mut self) -> _ADC14IE30W {
        _ADC14IE30W { w: self }
    }
    #[doc = "Bit 31 - Interrupt enable"]
    #[inline]
    pub fn adc14ie31(&mut self) -> _ADC14IE31W {
        _ADC14IE31W { w: self }
    }
}