#[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::EXTICR1 {
    #[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 `EXTI3`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI3R {
    #[doc = "Select PE3 as the source input for the EXTI3 external interrupt"]
    PE3,
    #[doc = "Select PA3 as the source input for the EXTI3 external interrupt"]
    PA3,
    #[doc = "Select PB3 as the source input for the EXTI3 external interrupt"]
    PB3,
    #[doc = "Select PC3 as the source input for the EXTI3 external interrupt"]
    PC3,
    #[doc = "Select PD3 as the source input for the EXTI3 external interrupt"]
    PD3,
    #[doc = "Select PF3 as the source input for the EXTI3 external interrupt"]
    PF3,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl EXTI3R {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            EXTI3R::PE3 => 4,
            EXTI3R::PA3 => 0,
            EXTI3R::PB3 => 1,
            EXTI3R::PC3 => 2,
            EXTI3R::PD3 => 3,
            EXTI3R::PF3 => 5,
            EXTI3R::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> EXTI3R {
        match value {
            4 => EXTI3R::PE3,
            0 => EXTI3R::PA3,
            1 => EXTI3R::PB3,
            2 => EXTI3R::PC3,
            3 => EXTI3R::PD3,
            5 => EXTI3R::PF3,
            i => EXTI3R::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `PE3`"]
    #[inline]
    pub fn is_pe3(&self) -> bool {
        *self == EXTI3R::PE3
    }
    #[doc = "Checks if the value of the field is `PA3`"]
    #[inline]
    pub fn is_pa3(&self) -> bool {
        *self == EXTI3R::PA3
    }
    #[doc = "Checks if the value of the field is `PB3`"]
    #[inline]
    pub fn is_pb3(&self) -> bool {
        *self == EXTI3R::PB3
    }
    #[doc = "Checks if the value of the field is `PC3`"]
    #[inline]
    pub fn is_pc3(&self) -> bool {
        *self == EXTI3R::PC3
    }
    #[doc = "Checks if the value of the field is `PD3`"]
    #[inline]
    pub fn is_pd3(&self) -> bool {
        *self == EXTI3R::PD3
    }
    #[doc = "Checks if the value of the field is `PF3`"]
    #[inline]
    pub fn is_pf3(&self) -> bool {
        *self == EXTI3R::PF3
    }
}
#[doc = "Possible values of the field `EXTI2`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI2R {
    #[doc = "Select PE2 as the source input for the EXTI2 external interrupt"]
    PE2,
    #[doc = "Select PA2 as the source input for the EXTI2 external interrupt"]
    PA2,
    #[doc = "Select PB2 as the source input for the EXTI2 external interrupt"]
    PB2,
    #[doc = "Select PC2 as the source input for the EXTI2 external interrupt"]
    PC2,
    #[doc = "Select PD2 as the source input for the EXTI2 external interrupt"]
    PD2,
    #[doc = "Select PF2 as the source input for the EXTI2 external interrupt"]
    PF2,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl EXTI2R {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            EXTI2R::PE2 => 4,
            EXTI2R::PA2 => 0,
            EXTI2R::PB2 => 1,
            EXTI2R::PC2 => 2,
            EXTI2R::PD2 => 3,
            EXTI2R::PF2 => 5,
            EXTI2R::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> EXTI2R {
        match value {
            4 => EXTI2R::PE2,
            0 => EXTI2R::PA2,
            1 => EXTI2R::PB2,
            2 => EXTI2R::PC2,
            3 => EXTI2R::PD2,
            5 => EXTI2R::PF2,
            i => EXTI2R::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `PE2`"]
    #[inline]
    pub fn is_pe2(&self) -> bool {
        *self == EXTI2R::PE2
    }
    #[doc = "Checks if the value of the field is `PA2`"]
    #[inline]
    pub fn is_pa2(&self) -> bool {
        *self == EXTI2R::PA2
    }
    #[doc = "Checks if the value of the field is `PB2`"]
    #[inline]
    pub fn is_pb2(&self) -> bool {
        *self == EXTI2R::PB2
    }
    #[doc = "Checks if the value of the field is `PC2`"]
    #[inline]
    pub fn is_pc2(&self) -> bool {
        *self == EXTI2R::PC2
    }
    #[doc = "Checks if the value of the field is `PD2`"]
    #[inline]
    pub fn is_pd2(&self) -> bool {
        *self == EXTI2R::PD2
    }
    #[doc = "Checks if the value of the field is `PF2`"]
    #[inline]
    pub fn is_pf2(&self) -> bool {
        *self == EXTI2R::PF2
    }
}
#[doc = "Possible values of the field `EXTI1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI1R {
    #[doc = "Select PE1 as the source input for the EXTI1 external interrupt"]
    PE1,
    #[doc = "Select PA1 as the source input for the EXTI1 external interrupt"]
    PA1,
    #[doc = "Select PB1 as the source input for the EXTI1 external interrupt"]
    PB1,
    #[doc = "Select PC1 as the source input for the EXTI1 external interrupt"]
    PC1,
    #[doc = "Select PD1 as the source input for the EXTI1 external interrupt"]
    PD1,
    #[doc = "Select PF1 as the source input for the EXTI1 external interrupt"]
    PF1,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl EXTI1R {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            EXTI1R::PE1 => 4,
            EXTI1R::PA1 => 0,
            EXTI1R::PB1 => 1,
            EXTI1R::PC1 => 2,
            EXTI1R::PD1 => 3,
            EXTI1R::PF1 => 5,
            EXTI1R::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> EXTI1R {
        match value {
            4 => EXTI1R::PE1,
            0 => EXTI1R::PA1,
            1 => EXTI1R::PB1,
            2 => EXTI1R::PC1,
            3 => EXTI1R::PD1,
            5 => EXTI1R::PF1,
            i => EXTI1R::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `PE1`"]
    #[inline]
    pub fn is_pe1(&self) -> bool {
        *self == EXTI1R::PE1
    }
    #[doc = "Checks if the value of the field is `PA1`"]
    #[inline]
    pub fn is_pa1(&self) -> bool {
        *self == EXTI1R::PA1
    }
    #[doc = "Checks if the value of the field is `PB1`"]
    #[inline]
    pub fn is_pb1(&self) -> bool {
        *self == EXTI1R::PB1
    }
    #[doc = "Checks if the value of the field is `PC1`"]
    #[inline]
    pub fn is_pc1(&self) -> bool {
        *self == EXTI1R::PC1
    }
    #[doc = "Checks if the value of the field is `PD1`"]
    #[inline]
    pub fn is_pd1(&self) -> bool {
        *self == EXTI1R::PD1
    }
    #[doc = "Checks if the value of the field is `PF1`"]
    #[inline]
    pub fn is_pf1(&self) -> bool {
        *self == EXTI1R::PF1
    }
}
#[doc = "Possible values of the field `EXTI0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI0R {
    #[doc = "Select PE0 as the source input for the EXTI0 external interrupt"]
    PE0,
    #[doc = "Select PA0 as the source input for the EXTI0 external interrupt"]
    PA0,
    #[doc = "Select PB0 as the source input for the EXTI0 external interrupt"]
    PB0,
    #[doc = "Select PC0 as the source input for the EXTI0 external interrupt"]
    PC0,
    #[doc = "Select PD0 as the source input for the EXTI0 external interrupt"]
    PD0,
    #[doc = "Select PF0 as the source input for the EXTI0 external interrupt"]
    PF0,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl EXTI0R {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            EXTI0R::PE0 => 4,
            EXTI0R::PA0 => 0,
            EXTI0R::PB0 => 1,
            EXTI0R::PC0 => 2,
            EXTI0R::PD0 => 3,
            EXTI0R::PF0 => 5,
            EXTI0R::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> EXTI0R {
        match value {
            4 => EXTI0R::PE0,
            0 => EXTI0R::PA0,
            1 => EXTI0R::PB0,
            2 => EXTI0R::PC0,
            3 => EXTI0R::PD0,
            5 => EXTI0R::PF0,
            i => EXTI0R::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `PE0`"]
    #[inline]
    pub fn is_pe0(&self) -> bool {
        *self == EXTI0R::PE0
    }
    #[doc = "Checks if the value of the field is `PA0`"]
    #[inline]
    pub fn is_pa0(&self) -> bool {
        *self == EXTI0R::PA0
    }
    #[doc = "Checks if the value of the field is `PB0`"]
    #[inline]
    pub fn is_pb0(&self) -> bool {
        *self == EXTI0R::PB0
    }
    #[doc = "Checks if the value of the field is `PC0`"]
    #[inline]
    pub fn is_pc0(&self) -> bool {
        *self == EXTI0R::PC0
    }
    #[doc = "Checks if the value of the field is `PD0`"]
    #[inline]
    pub fn is_pd0(&self) -> bool {
        *self == EXTI0R::PD0
    }
    #[doc = "Checks if the value of the field is `PF0`"]
    #[inline]
    pub fn is_pf0(&self) -> bool {
        *self == EXTI0R::PF0
    }
}
#[doc = "Values that can be written to the field `EXTI3`"]
pub enum EXTI3W {
    #[doc = "Select PE3 as the source input for the EXTI3 external interrupt"]
    PE3,
    #[doc = "Select PA3 as the source input for the EXTI3 external interrupt"]
    PA3,
    #[doc = "Select PB3 as the source input for the EXTI3 external interrupt"]
    PB3,
    #[doc = "Select PC3 as the source input for the EXTI3 external interrupt"]
    PC3,
    #[doc = "Select PD3 as the source input for the EXTI3 external interrupt"]
    PD3,
    #[doc = "Select PF3 as the source input for the EXTI3 external interrupt"]
    PF3,
}
impl EXTI3W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            EXTI3W::PE3 => 4,
            EXTI3W::PA3 => 0,
            EXTI3W::PB3 => 1,
            EXTI3W::PC3 => 2,
            EXTI3W::PD3 => 3,
            EXTI3W::PF3 => 5,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EXTI3W<'a> {
    w: &'a mut W,
}
impl<'a> _EXTI3W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EXTI3W) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "Select PE3 as the source input for the EXTI3 external interrupt"]
    #[inline]
    pub fn pe3(self) -> &'a mut W {
        self.variant(EXTI3W::PE3)
    }
    #[doc = "Select PA3 as the source input for the EXTI3 external interrupt"]
    #[inline]
    pub fn pa3(self) -> &'a mut W {
        self.variant(EXTI3W::PA3)
    }
    #[doc = "Select PB3 as the source input for the EXTI3 external interrupt"]
    #[inline]
    pub fn pb3(self) -> &'a mut W {
        self.variant(EXTI3W::PB3)
    }
    #[doc = "Select PC3 as the source input for the EXTI3 external interrupt"]
    #[inline]
    pub fn pc3(self) -> &'a mut W {
        self.variant(EXTI3W::PC3)
    }
    #[doc = "Select PD3 as the source input for the EXTI3 external interrupt"]
    #[inline]
    pub fn pd3(self) -> &'a mut W {
        self.variant(EXTI3W::PD3)
    }
    #[doc = "Select PF3 as the source input for the EXTI3 external interrupt"]
    #[inline]
    pub fn pf3(self) -> &'a mut W {
        self.variant(EXTI3W::PF3)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        const MASK: u8 = 15;
        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 `EXTI2`"]
pub enum EXTI2W {
    #[doc = "Select PE2 as the source input for the EXTI2 external interrupt"]
    PE2,
    #[doc = "Select PA2 as the source input for the EXTI2 external interrupt"]
    PA2,
    #[doc = "Select PB2 as the source input for the EXTI2 external interrupt"]
    PB2,
    #[doc = "Select PC2 as the source input for the EXTI2 external interrupt"]
    PC2,
    #[doc = "Select PD2 as the source input for the EXTI2 external interrupt"]
    PD2,
    #[doc = "Select PF2 as the source input for the EXTI2 external interrupt"]
    PF2,
}
impl EXTI2W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            EXTI2W::PE2 => 4,
            EXTI2W::PA2 => 0,
            EXTI2W::PB2 => 1,
            EXTI2W::PC2 => 2,
            EXTI2W::PD2 => 3,
            EXTI2W::PF2 => 5,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EXTI2W<'a> {
    w: &'a mut W,
}
impl<'a> _EXTI2W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EXTI2W) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "Select PE2 as the source input for the EXTI2 external interrupt"]
    #[inline]
    pub fn pe2(self) -> &'a mut W {
        self.variant(EXTI2W::PE2)
    }
    #[doc = "Select PA2 as the source input for the EXTI2 external interrupt"]
    #[inline]
    pub fn pa2(self) -> &'a mut W {
        self.variant(EXTI2W::PA2)
    }
    #[doc = "Select PB2 as the source input for the EXTI2 external interrupt"]
    #[inline]
    pub fn pb2(self) -> &'a mut W {
        self.variant(EXTI2W::PB2)
    }
    #[doc = "Select PC2 as the source input for the EXTI2 external interrupt"]
    #[inline]
    pub fn pc2(self) -> &'a mut W {
        self.variant(EXTI2W::PC2)
    }
    #[doc = "Select PD2 as the source input for the EXTI2 external interrupt"]
    #[inline]
    pub fn pd2(self) -> &'a mut W {
        self.variant(EXTI2W::PD2)
    }
    #[doc = "Select PF2 as the source input for the EXTI2 external interrupt"]
    #[inline]
    pub fn pf2(self) -> &'a mut W {
        self.variant(EXTI2W::PF2)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        const MASK: u8 = 15;
        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 `EXTI1`"]
pub enum EXTI1W {
    #[doc = "Select PE1 as the source input for the EXTI1 external interrupt"]
    PE1,
    #[doc = "Select PA1 as the source input for the EXTI1 external interrupt"]
    PA1,
    #[doc = "Select PB1 as the source input for the EXTI1 external interrupt"]
    PB1,
    #[doc = "Select PC1 as the source input for the EXTI1 external interrupt"]
    PC1,
    #[doc = "Select PD1 as the source input for the EXTI1 external interrupt"]
    PD1,
    #[doc = "Select PF1 as the source input for the EXTI1 external interrupt"]
    PF1,
}
impl EXTI1W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            EXTI1W::PE1 => 4,
            EXTI1W::PA1 => 0,
            EXTI1W::PB1 => 1,
            EXTI1W::PC1 => 2,
            EXTI1W::PD1 => 3,
            EXTI1W::PF1 => 5,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EXTI1W<'a> {
    w: &'a mut W,
}
impl<'a> _EXTI1W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EXTI1W) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "Select PE1 as the source input for the EXTI1 external interrupt"]
    #[inline]
    pub fn pe1(self) -> &'a mut W {
        self.variant(EXTI1W::PE1)
    }
    #[doc = "Select PA1 as the source input for the EXTI1 external interrupt"]
    #[inline]
    pub fn pa1(self) -> &'a mut W {
        self.variant(EXTI1W::PA1)
    }
    #[doc = "Select PB1 as the source input for the EXTI1 external interrupt"]
    #[inline]
    pub fn pb1(self) -> &'a mut W {
        self.variant(EXTI1W::PB1)
    }
    #[doc = "Select PC1 as the source input for the EXTI1 external interrupt"]
    #[inline]
    pub fn pc1(self) -> &'a mut W {
        self.variant(EXTI1W::PC1)
    }
    #[doc = "Select PD1 as the source input for the EXTI1 external interrupt"]
    #[inline]
    pub fn pd1(self) -> &'a mut W {
        self.variant(EXTI1W::PD1)
    }
    #[doc = "Select PF1 as the source input for the EXTI1 external interrupt"]
    #[inline]
    pub fn pf1(self) -> &'a mut W {
        self.variant(EXTI1W::PF1)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        const MASK: u8 = 15;
        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 `EXTI0`"]
pub enum EXTI0W {
    #[doc = "Select PE0 as the source input for the EXTI0 external interrupt"]
    PE0,
    #[doc = "Select PA0 as the source input for the EXTI0 external interrupt"]
    PA0,
    #[doc = "Select PB0 as the source input for the EXTI0 external interrupt"]
    PB0,
    #[doc = "Select PC0 as the source input for the EXTI0 external interrupt"]
    PC0,
    #[doc = "Select PD0 as the source input for the EXTI0 external interrupt"]
    PD0,
    #[doc = "Select PF0 as the source input for the EXTI0 external interrupt"]
    PF0,
}
impl EXTI0W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            EXTI0W::PE0 => 4,
            EXTI0W::PA0 => 0,
            EXTI0W::PB0 => 1,
            EXTI0W::PC0 => 2,
            EXTI0W::PD0 => 3,
            EXTI0W::PF0 => 5,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EXTI0W<'a> {
    w: &'a mut W,
}
impl<'a> _EXTI0W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EXTI0W) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "Select PE0 as the source input for the EXTI0 external interrupt"]
    #[inline]
    pub fn pe0(self) -> &'a mut W {
        self.variant(EXTI0W::PE0)
    }
    #[doc = "Select PA0 as the source input for the EXTI0 external interrupt"]
    #[inline]
    pub fn pa0(self) -> &'a mut W {
        self.variant(EXTI0W::PA0)
    }
    #[doc = "Select PB0 as the source input for the EXTI0 external interrupt"]
    #[inline]
    pub fn pb0(self) -> &'a mut W {
        self.variant(EXTI0W::PB0)
    }
    #[doc = "Select PC0 as the source input for the EXTI0 external interrupt"]
    #[inline]
    pub fn pc0(self) -> &'a mut W {
        self.variant(EXTI0W::PC0)
    }
    #[doc = "Select PD0 as the source input for the EXTI0 external interrupt"]
    #[inline]
    pub fn pd0(self) -> &'a mut W {
        self.variant(EXTI0W::PD0)
    }
    #[doc = "Select PF0 as the source input for the EXTI0 external interrupt"]
    #[inline]
    pub fn pf0(self) -> &'a mut W {
        self.variant(EXTI0W::PF0)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        const MASK: u8 = 15;
        const OFFSET: u8 = 0;
        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 = "Bits 12:15 - EXTI 3 configuration bits"]
    #[inline]
    pub fn exti3(&self) -> EXTI3R {
        EXTI3R::_from({
            const MASK: u8 = 15;
            const OFFSET: u8 = 12;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
    #[doc = "Bits 8:11 - EXTI 2 configuration bits"]
    #[inline]
    pub fn exti2(&self) -> EXTI2R {
        EXTI2R::_from({
            const MASK: u8 = 15;
            const OFFSET: u8 = 8;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
    #[doc = "Bits 4:7 - EXTI 1 configuration bits"]
    #[inline]
    pub fn exti1(&self) -> EXTI1R {
        EXTI1R::_from({
            const MASK: u8 = 15;
            const OFFSET: u8 = 4;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
    #[doc = "Bits 0:3 - EXTI 0 configuration bits"]
    #[inline]
    pub fn exti0(&self) -> EXTI0R {
        EXTI0R::_from({
            const MASK: u8 = 15;
            const OFFSET: u8 = 0;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
}
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 = "Bits 12:15 - EXTI 3 configuration bits"]
    #[inline]
    pub fn exti3(&mut self) -> _EXTI3W {
        _EXTI3W { w: self }
    }
    #[doc = "Bits 8:11 - EXTI 2 configuration bits"]
    #[inline]
    pub fn exti2(&mut self) -> _EXTI2W {
        _EXTI2W { w: self }
    }
    #[doc = "Bits 4:7 - EXTI 1 configuration bits"]
    #[inline]
    pub fn exti1(&mut self) -> _EXTI1W {
        _EXTI1W { w: self }
    }
    #[doc = "Bits 0:3 - EXTI 0 configuration bits"]
    #[inline]
    pub fn exti0(&mut self) -> _EXTI0W {
        _EXTI0W { w: self }
    }
}