#[doc = "Register `FGPFRLO` reader"]
pub struct R(crate::R<FGPFRLO_SPEC>);
impl core::ops::Deref for R {
    type Target = crate::R<FGPFRLO_SPEC>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<crate::R<FGPFRLO_SPEC>> for R {
    #[inline(always)]
    fn from(reader: crate::R<FGPFRLO_SPEC>) -> Self {
        R(reader)
    }
}
#[doc = "Field `LOCK0` reader - Lock Bit 0"]
pub struct LOCK0_R(crate::FieldReader<bool, bool>);
impl LOCK0_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK0_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK0_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK1` reader - Lock Bit 1"]
pub struct LOCK1_R(crate::FieldReader<bool, bool>);
impl LOCK1_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK1_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK1_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK2` reader - Lock Bit 2"]
pub struct LOCK2_R(crate::FieldReader<bool, bool>);
impl LOCK2_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK2_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK2_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK3` reader - Lock Bit 3"]
pub struct LOCK3_R(crate::FieldReader<bool, bool>);
impl LOCK3_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK3_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK3_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK4` reader - Lock Bit 4"]
pub struct LOCK4_R(crate::FieldReader<bool, bool>);
impl LOCK4_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK4_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK4_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK5` reader - Lock Bit 5"]
pub struct LOCK5_R(crate::FieldReader<bool, bool>);
impl LOCK5_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK5_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK5_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK6` reader - Lock Bit 6"]
pub struct LOCK6_R(crate::FieldReader<bool, bool>);
impl LOCK6_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK6_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK6_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK7` reader - Lock Bit 7"]
pub struct LOCK7_R(crate::FieldReader<bool, bool>);
impl LOCK7_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK7_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK7_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK8` reader - Lock Bit 8"]
pub struct LOCK8_R(crate::FieldReader<bool, bool>);
impl LOCK8_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK8_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK8_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK9` reader - Lock Bit 9"]
pub struct LOCK9_R(crate::FieldReader<bool, bool>);
impl LOCK9_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK9_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK9_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK10` reader - Lock Bit 10"]
pub struct LOCK10_R(crate::FieldReader<bool, bool>);
impl LOCK10_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK10_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK10_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK11` reader - Lock Bit 11"]
pub struct LOCK11_R(crate::FieldReader<bool, bool>);
impl LOCK11_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK11_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK11_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK12` reader - Lock Bit 12"]
pub struct LOCK12_R(crate::FieldReader<bool, bool>);
impl LOCK12_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK12_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK12_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK13` reader - Lock Bit 13"]
pub struct LOCK13_R(crate::FieldReader<bool, bool>);
impl LOCK13_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK13_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK13_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK14` reader - Lock Bit 14"]
pub struct LOCK14_R(crate::FieldReader<bool, bool>);
impl LOCK14_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK14_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK14_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `LOCK15` reader - Lock Bit 15"]
pub struct LOCK15_R(crate::FieldReader<bool, bool>);
impl LOCK15_R {
    pub(crate) fn new(bits: bool) -> Self {
        LOCK15_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for LOCK15_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF16` reader - General Purpose Fuse 16"]
pub struct GPF16_R(crate::FieldReader<bool, bool>);
impl GPF16_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF16_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF16_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF17` reader - General Purpose Fuse 17"]
pub struct GPF17_R(crate::FieldReader<bool, bool>);
impl GPF17_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF17_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF17_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF18` reader - General Purpose Fuse 18"]
pub struct GPF18_R(crate::FieldReader<bool, bool>);
impl GPF18_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF18_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF18_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF19` reader - General Purpose Fuse 19"]
pub struct GPF19_R(crate::FieldReader<bool, bool>);
impl GPF19_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF19_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF19_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF20` reader - General Purpose Fuse 20"]
pub struct GPF20_R(crate::FieldReader<bool, bool>);
impl GPF20_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF20_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF20_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF21` reader - General Purpose Fuse 21"]
pub struct GPF21_R(crate::FieldReader<bool, bool>);
impl GPF21_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF21_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF21_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF22` reader - General Purpose Fuse 22"]
pub struct GPF22_R(crate::FieldReader<bool, bool>);
impl GPF22_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF22_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF22_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF23` reader - General Purpose Fuse 23"]
pub struct GPF23_R(crate::FieldReader<bool, bool>);
impl GPF23_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF23_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF23_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF24` reader - General Purpose Fuse 24"]
pub struct GPF24_R(crate::FieldReader<bool, bool>);
impl GPF24_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF24_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF24_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF25` reader - General Purpose Fuse 25"]
pub struct GPF25_R(crate::FieldReader<bool, bool>);
impl GPF25_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF25_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF25_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF26` reader - General Purpose Fuse 26"]
pub struct GPF26_R(crate::FieldReader<bool, bool>);
impl GPF26_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF26_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF26_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF27` reader - General Purpose Fuse 27"]
pub struct GPF27_R(crate::FieldReader<bool, bool>);
impl GPF27_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF27_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF27_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF28` reader - General Purpose Fuse 28"]
pub struct GPF28_R(crate::FieldReader<bool, bool>);
impl GPF28_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF28_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF28_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF29` reader - General Purpose Fuse 29"]
pub struct GPF29_R(crate::FieldReader<bool, bool>);
impl GPF29_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF29_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF29_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF30` reader - General Purpose Fuse 30"]
pub struct GPF30_R(crate::FieldReader<bool, bool>);
impl GPF30_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF30_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF30_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `GPF31` reader - General Purpose Fuse 31"]
pub struct GPF31_R(crate::FieldReader<bool, bool>);
impl GPF31_R {
    pub(crate) fn new(bits: bool) -> Self {
        GPF31_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for GPF31_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl R {
    #[doc = "Bit 0 - Lock Bit 0"]
    #[inline(always)]
    pub fn lock0(&self) -> LOCK0_R {
        LOCK0_R::new((self.bits & 0x01) != 0)
    }
    #[doc = "Bit 1 - Lock Bit 1"]
    #[inline(always)]
    pub fn lock1(&self) -> LOCK1_R {
        LOCK1_R::new(((self.bits >> 1) & 0x01) != 0)
    }
    #[doc = "Bit 2 - Lock Bit 2"]
    #[inline(always)]
    pub fn lock2(&self) -> LOCK2_R {
        LOCK2_R::new(((self.bits >> 2) & 0x01) != 0)
    }
    #[doc = "Bit 3 - Lock Bit 3"]
    #[inline(always)]
    pub fn lock3(&self) -> LOCK3_R {
        LOCK3_R::new(((self.bits >> 3) & 0x01) != 0)
    }
    #[doc = "Bit 4 - Lock Bit 4"]
    #[inline(always)]
    pub fn lock4(&self) -> LOCK4_R {
        LOCK4_R::new(((self.bits >> 4) & 0x01) != 0)
    }
    #[doc = "Bit 5 - Lock Bit 5"]
    #[inline(always)]
    pub fn lock5(&self) -> LOCK5_R {
        LOCK5_R::new(((self.bits >> 5) & 0x01) != 0)
    }
    #[doc = "Bit 6 - Lock Bit 6"]
    #[inline(always)]
    pub fn lock6(&self) -> LOCK6_R {
        LOCK6_R::new(((self.bits >> 6) & 0x01) != 0)
    }
    #[doc = "Bit 7 - Lock Bit 7"]
    #[inline(always)]
    pub fn lock7(&self) -> LOCK7_R {
        LOCK7_R::new(((self.bits >> 7) & 0x01) != 0)
    }
    #[doc = "Bit 8 - Lock Bit 8"]
    #[inline(always)]
    pub fn lock8(&self) -> LOCK8_R {
        LOCK8_R::new(((self.bits >> 8) & 0x01) != 0)
    }
    #[doc = "Bit 9 - Lock Bit 9"]
    #[inline(always)]
    pub fn lock9(&self) -> LOCK9_R {
        LOCK9_R::new(((self.bits >> 9) & 0x01) != 0)
    }
    #[doc = "Bit 10 - Lock Bit 10"]
    #[inline(always)]
    pub fn lock10(&self) -> LOCK10_R {
        LOCK10_R::new(((self.bits >> 10) & 0x01) != 0)
    }
    #[doc = "Bit 11 - Lock Bit 11"]
    #[inline(always)]
    pub fn lock11(&self) -> LOCK11_R {
        LOCK11_R::new(((self.bits >> 11) & 0x01) != 0)
    }
    #[doc = "Bit 12 - Lock Bit 12"]
    #[inline(always)]
    pub fn lock12(&self) -> LOCK12_R {
        LOCK12_R::new(((self.bits >> 12) & 0x01) != 0)
    }
    #[doc = "Bit 13 - Lock Bit 13"]
    #[inline(always)]
    pub fn lock13(&self) -> LOCK13_R {
        LOCK13_R::new(((self.bits >> 13) & 0x01) != 0)
    }
    #[doc = "Bit 14 - Lock Bit 14"]
    #[inline(always)]
    pub fn lock14(&self) -> LOCK14_R {
        LOCK14_R::new(((self.bits >> 14) & 0x01) != 0)
    }
    #[doc = "Bit 15 - Lock Bit 15"]
    #[inline(always)]
    pub fn lock15(&self) -> LOCK15_R {
        LOCK15_R::new(((self.bits >> 15) & 0x01) != 0)
    }
    #[doc = "Bit 16 - General Purpose Fuse 16"]
    #[inline(always)]
    pub fn gpf16(&self) -> GPF16_R {
        GPF16_R::new(((self.bits >> 16) & 0x01) != 0)
    }
    #[doc = "Bit 17 - General Purpose Fuse 17"]
    #[inline(always)]
    pub fn gpf17(&self) -> GPF17_R {
        GPF17_R::new(((self.bits >> 17) & 0x01) != 0)
    }
    #[doc = "Bit 18 - General Purpose Fuse 18"]
    #[inline(always)]
    pub fn gpf18(&self) -> GPF18_R {
        GPF18_R::new(((self.bits >> 18) & 0x01) != 0)
    }
    #[doc = "Bit 19 - General Purpose Fuse 19"]
    #[inline(always)]
    pub fn gpf19(&self) -> GPF19_R {
        GPF19_R::new(((self.bits >> 19) & 0x01) != 0)
    }
    #[doc = "Bit 20 - General Purpose Fuse 20"]
    #[inline(always)]
    pub fn gpf20(&self) -> GPF20_R {
        GPF20_R::new(((self.bits >> 20) & 0x01) != 0)
    }
    #[doc = "Bit 21 - General Purpose Fuse 21"]
    #[inline(always)]
    pub fn gpf21(&self) -> GPF21_R {
        GPF21_R::new(((self.bits >> 21) & 0x01) != 0)
    }
    #[doc = "Bit 22 - General Purpose Fuse 22"]
    #[inline(always)]
    pub fn gpf22(&self) -> GPF22_R {
        GPF22_R::new(((self.bits >> 22) & 0x01) != 0)
    }
    #[doc = "Bit 23 - General Purpose Fuse 23"]
    #[inline(always)]
    pub fn gpf23(&self) -> GPF23_R {
        GPF23_R::new(((self.bits >> 23) & 0x01) != 0)
    }
    #[doc = "Bit 24 - General Purpose Fuse 24"]
    #[inline(always)]
    pub fn gpf24(&self) -> GPF24_R {
        GPF24_R::new(((self.bits >> 24) & 0x01) != 0)
    }
    #[doc = "Bit 25 - General Purpose Fuse 25"]
    #[inline(always)]
    pub fn gpf25(&self) -> GPF25_R {
        GPF25_R::new(((self.bits >> 25) & 0x01) != 0)
    }
    #[doc = "Bit 26 - General Purpose Fuse 26"]
    #[inline(always)]
    pub fn gpf26(&self) -> GPF26_R {
        GPF26_R::new(((self.bits >> 26) & 0x01) != 0)
    }
    #[doc = "Bit 27 - General Purpose Fuse 27"]
    #[inline(always)]
    pub fn gpf27(&self) -> GPF27_R {
        GPF27_R::new(((self.bits >> 27) & 0x01) != 0)
    }
    #[doc = "Bit 28 - General Purpose Fuse 28"]
    #[inline(always)]
    pub fn gpf28(&self) -> GPF28_R {
        GPF28_R::new(((self.bits >> 28) & 0x01) != 0)
    }
    #[doc = "Bit 29 - General Purpose Fuse 29"]
    #[inline(always)]
    pub fn gpf29(&self) -> GPF29_R {
        GPF29_R::new(((self.bits >> 29) & 0x01) != 0)
    }
    #[doc = "Bit 30 - General Purpose Fuse 30"]
    #[inline(always)]
    pub fn gpf30(&self) -> GPF30_R {
        GPF30_R::new(((self.bits >> 30) & 0x01) != 0)
    }
    #[doc = "Bit 31 - General Purpose Fuse 31"]
    #[inline(always)]
    pub fn gpf31(&self) -> GPF31_R {
        GPF31_R::new(((self.bits >> 31) & 0x01) != 0)
    }
}
#[doc = "Flash Controller General Purpose Fuse Register Low\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [fgpfrlo](index.html) module"]
pub struct FGPFRLO_SPEC;
impl crate::RegisterSpec for FGPFRLO_SPEC {
    type Ux = u32;
}
#[doc = "`read()` method returns [fgpfrlo::R](R) reader structure"]
impl crate::Readable for FGPFRLO_SPEC {
    type Reader = R;
}
#[doc = "`reset()` method sets FGPFRLO to value 0"]
impl crate::Resettable for FGPFRLO_SPEC {
    #[inline(always)]
    fn reset_value() -> Self::Ux {
        0
    }
}
