#[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::EXTICR2 {
    #[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 `EXTI7`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI7R {
    #[doc = "Select PE7 as the source input for the EXTI7 external interrupt"]
    PE7,
    #[doc = "Select PA7 as the source input for the EXTI7 external interrupt"]
    PA7,
    #[doc = "Select PB7 as the source input for the EXTI7 external interrupt"]
    PB7,
    #[doc = "Select PC7 as the source input for the EXTI7 external interrupt"]
    PC7,
    #[doc = "Select PD7 as the source input for the EXTI7 external interrupt"]
    PD7,
    #[doc = "Select PF7 as the source input for the EXTI7 external interrupt"]
    PF7,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl EXTI7R {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            EXTI7R::PE7 => 4,
            EXTI7R::PA7 => 0,
            EXTI7R::PB7 => 1,
            EXTI7R::PC7 => 2,
            EXTI7R::PD7 => 3,
            EXTI7R::PF7 => 5,
            EXTI7R::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> EXTI7R {
        match value {
            4 => EXTI7R::PE7,
            0 => EXTI7R::PA7,
            1 => EXTI7R::PB7,
            2 => EXTI7R::PC7,
            3 => EXTI7R::PD7,
            5 => EXTI7R::PF7,
            i => EXTI7R::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `PE7`"]
    #[inline]
    pub fn is_pe7(&self) -> bool {
        *self == EXTI7R::PE7
    }
    #[doc = "Checks if the value of the field is `PA7`"]
    #[inline]
    pub fn is_pa7(&self) -> bool {
        *self == EXTI7R::PA7
    }
    #[doc = "Checks if the value of the field is `PB7`"]
    #[inline]
    pub fn is_pb7(&self) -> bool {
        *self == EXTI7R::PB7
    }
    #[doc = "Checks if the value of the field is `PC7`"]
    #[inline]
    pub fn is_pc7(&self) -> bool {
        *self == EXTI7R::PC7
    }
    #[doc = "Checks if the value of the field is `PD7`"]
    #[inline]
    pub fn is_pd7(&self) -> bool {
        *self == EXTI7R::PD7
    }
    #[doc = "Checks if the value of the field is `PF7`"]
    #[inline]
    pub fn is_pf7(&self) -> bool {
        *self == EXTI7R::PF7
    }
}
#[doc = "Possible values of the field `EXTI6`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI6R {
    #[doc = "Select PE6 as the source input for the EXTI6 external interrupt"]
    PE6,
    #[doc = "Select PA6 as the source input for the EXTI6 external interrupt"]
    PA6,
    #[doc = "Select PB6 as the source input for the EXTI6 external interrupt"]
    PB6,
    #[doc = "Select PC6 as the source input for the EXTI6 external interrupt"]
    PC6,
    #[doc = "Select PD6 as the source input for the EXTI6 external interrupt"]
    PD6,
    #[doc = "Select PF6 as the source input for the EXTI6 external interrupt"]
    PF6,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl EXTI6R {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            EXTI6R::PE6 => 4,
            EXTI6R::PA6 => 0,
            EXTI6R::PB6 => 1,
            EXTI6R::PC6 => 2,
            EXTI6R::PD6 => 3,
            EXTI6R::PF6 => 5,
            EXTI6R::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> EXTI6R {
        match value {
            4 => EXTI6R::PE6,
            0 => EXTI6R::PA6,
            1 => EXTI6R::PB6,
            2 => EXTI6R::PC6,
            3 => EXTI6R::PD6,
            5 => EXTI6R::PF6,
            i => EXTI6R::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `PE6`"]
    #[inline]
    pub fn is_pe6(&self) -> bool {
        *self == EXTI6R::PE6
    }
    #[doc = "Checks if the value of the field is `PA6`"]
    #[inline]
    pub fn is_pa6(&self) -> bool {
        *self == EXTI6R::PA6
    }
    #[doc = "Checks if the value of the field is `PB6`"]
    #[inline]
    pub fn is_pb6(&self) -> bool {
        *self == EXTI6R::PB6
    }
    #[doc = "Checks if the value of the field is `PC6`"]
    #[inline]
    pub fn is_pc6(&self) -> bool {
        *self == EXTI6R::PC6
    }
    #[doc = "Checks if the value of the field is `PD6`"]
    #[inline]
    pub fn is_pd6(&self) -> bool {
        *self == EXTI6R::PD6
    }
    #[doc = "Checks if the value of the field is `PF6`"]
    #[inline]
    pub fn is_pf6(&self) -> bool {
        *self == EXTI6R::PF6
    }
}
#[doc = "Possible values of the field `EXTI5`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI5R {
    #[doc = "Select PE5 as the source input for the EXTI5 external interrupt"]
    PE5,
    #[doc = "Select PA5 as the source input for the EXTI5 external interrupt"]
    PA5,
    #[doc = "Select PB5 as the source input for the EXTI5 external interrupt"]
    PB5,
    #[doc = "Select PC5 as the source input for the EXTI5 external interrupt"]
    PC5,
    #[doc = "Select PD5 as the source input for the EXTI5 external interrupt"]
    PD5,
    #[doc = "Select PF5 as the source input for the EXTI5 external interrupt"]
    PF5,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl EXTI5R {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            EXTI5R::PE5 => 4,
            EXTI5R::PA5 => 0,
            EXTI5R::PB5 => 1,
            EXTI5R::PC5 => 2,
            EXTI5R::PD5 => 3,
            EXTI5R::PF5 => 5,
            EXTI5R::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> EXTI5R {
        match value {
            4 => EXTI5R::PE5,
            0 => EXTI5R::PA5,
            1 => EXTI5R::PB5,
            2 => EXTI5R::PC5,
            3 => EXTI5R::PD5,
            5 => EXTI5R::PF5,
            i => EXTI5R::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `PE5`"]
    #[inline]
    pub fn is_pe5(&self) -> bool {
        *self == EXTI5R::PE5
    }
    #[doc = "Checks if the value of the field is `PA5`"]
    #[inline]
    pub fn is_pa5(&self) -> bool {
        *self == EXTI5R::PA5
    }
    #[doc = "Checks if the value of the field is `PB5`"]
    #[inline]
    pub fn is_pb5(&self) -> bool {
        *self == EXTI5R::PB5
    }
    #[doc = "Checks if the value of the field is `PC5`"]
    #[inline]
    pub fn is_pc5(&self) -> bool {
        *self == EXTI5R::PC5
    }
    #[doc = "Checks if the value of the field is `PD5`"]
    #[inline]
    pub fn is_pd5(&self) -> bool {
        *self == EXTI5R::PD5
    }
    #[doc = "Checks if the value of the field is `PF5`"]
    #[inline]
    pub fn is_pf5(&self) -> bool {
        *self == EXTI5R::PF5
    }
}
#[doc = "Possible values of the field `EXTI4`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EXTI4R {
    #[doc = "Select PE4 as the source input for the EXTI4 external interrupt"]
    PE4,
    #[doc = "Select PA4 as the source input for the EXTI4 external interrupt"]
    PA4,
    #[doc = "Select PB4 as the source input for the EXTI4 external interrupt"]
    PB4,
    #[doc = "Select PC4 as the source input for the EXTI4 external interrupt"]
    PC4,
    #[doc = "Select PD4 as the source input for the EXTI4 external interrupt"]
    PD4,
    #[doc = "Select PF4 as the source input for the EXTI4 external interrupt"]
    PF4,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl EXTI4R {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            EXTI4R::PE4 => 4,
            EXTI4R::PA4 => 0,
            EXTI4R::PB4 => 1,
            EXTI4R::PC4 => 2,
            EXTI4R::PD4 => 3,
            EXTI4R::PF4 => 5,
            EXTI4R::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> EXTI4R {
        match value {
            4 => EXTI4R::PE4,
            0 => EXTI4R::PA4,
            1 => EXTI4R::PB4,
            2 => EXTI4R::PC4,
            3 => EXTI4R::PD4,
            5 => EXTI4R::PF4,
            i => EXTI4R::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `PE4`"]
    #[inline]
    pub fn is_pe4(&self) -> bool {
        *self == EXTI4R::PE4
    }
    #[doc = "Checks if the value of the field is `PA4`"]
    #[inline]
    pub fn is_pa4(&self) -> bool {
        *self == EXTI4R::PA4
    }
    #[doc = "Checks if the value of the field is `PB4`"]
    #[inline]
    pub fn is_pb4(&self) -> bool {
        *self == EXTI4R::PB4
    }
    #[doc = "Checks if the value of the field is `PC4`"]
    #[inline]
    pub fn is_pc4(&self) -> bool {
        *self == EXTI4R::PC4
    }
    #[doc = "Checks if the value of the field is `PD4`"]
    #[inline]
    pub fn is_pd4(&self) -> bool {
        *self == EXTI4R::PD4
    }
    #[doc = "Checks if the value of the field is `PF4`"]
    #[inline]
    pub fn is_pf4(&self) -> bool {
        *self == EXTI4R::PF4
    }
}
#[doc = "Values that can be written to the field `EXTI7`"]
pub enum EXTI7W {
    #[doc = "Select PE7 as the source input for the EXTI7 external interrupt"]
    PE7,
    #[doc = "Select PA7 as the source input for the EXTI7 external interrupt"]
    PA7,
    #[doc = "Select PB7 as the source input for the EXTI7 external interrupt"]
    PB7,
    #[doc = "Select PC7 as the source input for the EXTI7 external interrupt"]
    PC7,
    #[doc = "Select PD7 as the source input for the EXTI7 external interrupt"]
    PD7,
    #[doc = "Select PF7 as the source input for the EXTI7 external interrupt"]
    PF7,
}
impl EXTI7W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            EXTI7W::PE7 => 4,
            EXTI7W::PA7 => 0,
            EXTI7W::PB7 => 1,
            EXTI7W::PC7 => 2,
            EXTI7W::PD7 => 3,
            EXTI7W::PF7 => 5,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EXTI7W<'a> {
    w: &'a mut W,
}
impl<'a> _EXTI7W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EXTI7W) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "Select PE7 as the source input for the EXTI7 external interrupt"]
    #[inline]
    pub fn pe7(self) -> &'a mut W {
        self.variant(EXTI7W::PE7)
    }
    #[doc = "Select PA7 as the source input for the EXTI7 external interrupt"]
    #[inline]
    pub fn pa7(self) -> &'a mut W {
        self.variant(EXTI7W::PA7)
    }
    #[doc = "Select PB7 as the source input for the EXTI7 external interrupt"]
    #[inline]
    pub fn pb7(self) -> &'a mut W {
        self.variant(EXTI7W::PB7)
    }
    #[doc = "Select PC7 as the source input for the EXTI7 external interrupt"]
    #[inline]
    pub fn pc7(self) -> &'a mut W {
        self.variant(EXTI7W::PC7)
    }
    #[doc = "Select PD7 as the source input for the EXTI7 external interrupt"]
    #[inline]
    pub fn pd7(self) -> &'a mut W {
        self.variant(EXTI7W::PD7)
    }
    #[doc = "Select PF7 as the source input for the EXTI7 external interrupt"]
    #[inline]
    pub fn pf7(self) -> &'a mut W {
        self.variant(EXTI7W::PF7)
    }
    #[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 `EXTI6`"]
pub enum EXTI6W {
    #[doc = "Select PE6 as the source input for the EXTI6 external interrupt"]
    PE6,
    #[doc = "Select PA6 as the source input for the EXTI6 external interrupt"]
    PA6,
    #[doc = "Select PB6 as the source input for the EXTI6 external interrupt"]
    PB6,
    #[doc = "Select PC6 as the source input for the EXTI6 external interrupt"]
    PC6,
    #[doc = "Select PD6 as the source input for the EXTI6 external interrupt"]
    PD6,
    #[doc = "Select PF6 as the source input for the EXTI6 external interrupt"]
    PF6,
}
impl EXTI6W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            EXTI6W::PE6 => 4,
            EXTI6W::PA6 => 0,
            EXTI6W::PB6 => 1,
            EXTI6W::PC6 => 2,
            EXTI6W::PD6 => 3,
            EXTI6W::PF6 => 5,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EXTI6W<'a> {
    w: &'a mut W,
}
impl<'a> _EXTI6W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EXTI6W) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "Select PE6 as the source input for the EXTI6 external interrupt"]
    #[inline]
    pub fn pe6(self) -> &'a mut W {
        self.variant(EXTI6W::PE6)
    }
    #[doc = "Select PA6 as the source input for the EXTI6 external interrupt"]
    #[inline]
    pub fn pa6(self) -> &'a mut W {
        self.variant(EXTI6W::PA6)
    }
    #[doc = "Select PB6 as the source input for the EXTI6 external interrupt"]
    #[inline]
    pub fn pb6(self) -> &'a mut W {
        self.variant(EXTI6W::PB6)
    }
    #[doc = "Select PC6 as the source input for the EXTI6 external interrupt"]
    #[inline]
    pub fn pc6(self) -> &'a mut W {
        self.variant(EXTI6W::PC6)
    }
    #[doc = "Select PD6 as the source input for the EXTI6 external interrupt"]
    #[inline]
    pub fn pd6(self) -> &'a mut W {
        self.variant(EXTI6W::PD6)
    }
    #[doc = "Select PF6 as the source input for the EXTI6 external interrupt"]
    #[inline]
    pub fn pf6(self) -> &'a mut W {
        self.variant(EXTI6W::PF6)
    }
    #[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 `EXTI5`"]
pub enum EXTI5W {
    #[doc = "Select PE5 as the source input for the EXTI5 external interrupt"]
    PE5,
    #[doc = "Select PA5 as the source input for the EXTI5 external interrupt"]
    PA5,
    #[doc = "Select PB5 as the source input for the EXTI5 external interrupt"]
    PB5,
    #[doc = "Select PC5 as the source input for the EXTI5 external interrupt"]
    PC5,
    #[doc = "Select PD5 as the source input for the EXTI5 external interrupt"]
    PD5,
    #[doc = "Select PF5 as the source input for the EXTI5 external interrupt"]
    PF5,
}
impl EXTI5W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            EXTI5W::PE5 => 4,
            EXTI5W::PA5 => 0,
            EXTI5W::PB5 => 1,
            EXTI5W::PC5 => 2,
            EXTI5W::PD5 => 3,
            EXTI5W::PF5 => 5,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EXTI5W<'a> {
    w: &'a mut W,
}
impl<'a> _EXTI5W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EXTI5W) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "Select PE5 as the source input for the EXTI5 external interrupt"]
    #[inline]
    pub fn pe5(self) -> &'a mut W {
        self.variant(EXTI5W::PE5)
    }
    #[doc = "Select PA5 as the source input for the EXTI5 external interrupt"]
    #[inline]
    pub fn pa5(self) -> &'a mut W {
        self.variant(EXTI5W::PA5)
    }
    #[doc = "Select PB5 as the source input for the EXTI5 external interrupt"]
    #[inline]
    pub fn pb5(self) -> &'a mut W {
        self.variant(EXTI5W::PB5)
    }
    #[doc = "Select PC5 as the source input for the EXTI5 external interrupt"]
    #[inline]
    pub fn pc5(self) -> &'a mut W {
        self.variant(EXTI5W::PC5)
    }
    #[doc = "Select PD5 as the source input for the EXTI5 external interrupt"]
    #[inline]
    pub fn pd5(self) -> &'a mut W {
        self.variant(EXTI5W::PD5)
    }
    #[doc = "Select PF5 as the source input for the EXTI5 external interrupt"]
    #[inline]
    pub fn pf5(self) -> &'a mut W {
        self.variant(EXTI5W::PF5)
    }
    #[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 `EXTI4`"]
pub enum EXTI4W {
    #[doc = "Select PE4 as the source input for the EXTI4 external interrupt"]
    PE4,
    #[doc = "Select PA4 as the source input for the EXTI4 external interrupt"]
    PA4,
    #[doc = "Select PB4 as the source input for the EXTI4 external interrupt"]
    PB4,
    #[doc = "Select PC4 as the source input for the EXTI4 external interrupt"]
    PC4,
    #[doc = "Select PD4 as the source input for the EXTI4 external interrupt"]
    PD4,
    #[doc = "Select PF4 as the source input for the EXTI4 external interrupt"]
    PF4,
}
impl EXTI4W {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            EXTI4W::PE4 => 4,
            EXTI4W::PA4 => 0,
            EXTI4W::PB4 => 1,
            EXTI4W::PC4 => 2,
            EXTI4W::PD4 => 3,
            EXTI4W::PF4 => 5,
        }
    }
}
#[doc = r" Proxy"]
pub struct _EXTI4W<'a> {
    w: &'a mut W,
}
impl<'a> _EXTI4W<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: EXTI4W) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "Select PE4 as the source input for the EXTI4 external interrupt"]
    #[inline]
    pub fn pe4(self) -> &'a mut W {
        self.variant(EXTI4W::PE4)
    }
    #[doc = "Select PA4 as the source input for the EXTI4 external interrupt"]
    #[inline]
    pub fn pa4(self) -> &'a mut W {
        self.variant(EXTI4W::PA4)
    }
    #[doc = "Select PB4 as the source input for the EXTI4 external interrupt"]
    #[inline]
    pub fn pb4(self) -> &'a mut W {
        self.variant(EXTI4W::PB4)
    }
    #[doc = "Select PC4 as the source input for the EXTI4 external interrupt"]
    #[inline]
    pub fn pc4(self) -> &'a mut W {
        self.variant(EXTI4W::PC4)
    }
    #[doc = "Select PD4 as the source input for the EXTI4 external interrupt"]
    #[inline]
    pub fn pd4(self) -> &'a mut W {
        self.variant(EXTI4W::PD4)
    }
    #[doc = "Select PF4 as the source input for the EXTI4 external interrupt"]
    #[inline]
    pub fn pf4(self) -> &'a mut W {
        self.variant(EXTI4W::PF4)
    }
    #[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 7 configuration bits"]
    #[inline]
    pub fn exti7(&self) -> EXTI7R {
        EXTI7R::_from({
            const MASK: u8 = 15;
            const OFFSET: u8 = 12;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
    #[doc = "Bits 8:11 - EXTI 6 configuration bits"]
    #[inline]
    pub fn exti6(&self) -> EXTI6R {
        EXTI6R::_from({
            const MASK: u8 = 15;
            const OFFSET: u8 = 8;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
    #[doc = "Bits 4:7 - EXTI 5 configuration bits"]
    #[inline]
    pub fn exti5(&self) -> EXTI5R {
        EXTI5R::_from({
            const MASK: u8 = 15;
            const OFFSET: u8 = 4;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
    #[doc = "Bits 0:3 - EXTI 4 configuration bits"]
    #[inline]
    pub fn exti4(&self) -> EXTI4R {
        EXTI4R::_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 7 configuration bits"]
    #[inline]
    pub fn exti7(&mut self) -> _EXTI7W {
        _EXTI7W { w: self }
    }
    #[doc = "Bits 8:11 - EXTI 6 configuration bits"]
    #[inline]
    pub fn exti6(&mut self) -> _EXTI6W {
        _EXTI6W { w: self }
    }
    #[doc = "Bits 4:7 - EXTI 5 configuration bits"]
    #[inline]
    pub fn exti5(&mut self) -> _EXTI5W {
        _EXTI5W { w: self }
    }
    #[doc = "Bits 0:3 - EXTI 4 configuration bits"]
    #[inline]
    pub fn exti4(&mut self) -> _EXTI4W {
        _EXTI4W { w: self }
    }
}