diff --git a/Cargo.toml b/Cargo.toml
index d462a3b52278790d9f28cb6bfea4f9d1029ef6aa..60f50f8908959e57cc18d64112938776125d1bd2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,17 +5,16 @@ description = "Peripheral access API for STM32F413 microcontrollers"
 keywords = ["no-std", "arm", "cortex-m", "stm32"]
 license = "MIT OR Apache-2.0"
 name = "stm32f413"
-#repository = "https://github.com/japaric/stm32f100xx"
-version = "0.2.0"
+version = "0.3.0"
 
 [dependencies]
-bare-metal = "0.1.1"
-cortex-m = "0.4.0"
+bare-metal = "0.2.0"
+cortex-m = "0.5.0"
 vcell = "0.1.0"
 
 [dependencies.cortex-m-rt]
 optional = true
-version = "0.3.0"
+version = "0.5.0"
 
 [features]
-rt = ["cortex-m-rt"]
\ No newline at end of file
+rt = ["cortex-m-rt/device"]
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
index c245e3f6cd9a699037efdcc8ced6855fdf60d3a2..5343176feb42f3ca5d9ea484f80497e94e525027 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,460 +1,652 @@
-# ! [ cfg_attr ( feature = "rt" , feature ( global_asm ) ) ] # ! [ cfg_attr ( feature = "rt" , feature ( macro_reexport ) ) ] # ! [ cfg_attr ( feature = "rt" , feature ( used ) ) ] # ! [ doc = "Peripheral access API for STM32F413 microcontrollers (generated using svd2rust v0.12.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.12.0/svd2rust/#peripheral-api" ] # ! [ allow ( private_no_mangle_statics ) ] # ! [ deny ( missing_docs ) ] # ! [ deny ( warnings ) ] # ! [ allow ( non_camel_case_types ) ] # ! [ feature ( const_fn ) ] # ! [ no_std ]
+#![doc = "Peripheral access API for STM32F413 microcontrollers (generated using svd2rust v0.13.1)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.13.1/svd2rust/#peripheral-api"]
+#![deny(missing_docs)]
+#![deny(warnings)]
+#![allow(non_camel_case_types)]
+#![no_std]
 extern crate bare_metal;
 extern crate cortex_m;
-#[macro_reexport(default_handler, exception)]
 #[cfg(feature = "rt")]
 extern crate cortex_m_rt;
 extern crate vcell;
-use core::ops::Deref;
 use core::marker::PhantomData;
+use core::ops::Deref;
 #[doc = r" Number available in the NVIC for configuring priority"]
 pub const NVIC_PRIO_BITS: u8 = 4;
-pub use interrupt::Interrupt;
+#[cfg(feature = "rt")]
+extern "C" {
+    fn WWDG();
+    fn PVD();
+    fn TAMP_STAMP();
+    fn RTC_WKUP();
+    fn FLASH();
+    fn RCC();
+    fn EXTI0();
+    fn EXTI1();
+    fn EXTI2();
+    fn EXTI3();
+    fn EXTI4();
+    fn DMA1_STREAM0();
+    fn DMA1_STREAM1();
+    fn DMA1_STREAM2();
+    fn DMA1_STREAM3();
+    fn DMA1_STREAM4();
+    fn DMA1_STREAM5();
+    fn DMA1_STREAM6();
+    fn ADC();
+    fn CAN1_TX();
+    fn CAN1_RX0();
+    fn CAN1_RX1();
+    fn CAN1_SCE();
+    fn EXTI9_5();
+    fn TIM1_BRK_TIM9();
+    fn TIM1_UP_TIM10();
+    fn TIM1_TRG_COM_TIM11();
+    fn TIM1_CC();
+    fn TIM2();
+    fn TIM3();
+    fn TIM4();
+    fn I2C1_EVT();
+    fn I2C1_ERR();
+    fn I2C2_EVT();
+    fn I2C2_ERR();
+    fn SPI1();
+    fn SPI2();
+    fn USART1();
+    fn USART2();
+    fn USART3();
+    fn EXTI15_10();
+    fn EXTI17_RTC_ALARM();
+    fn EXTI18_OTG_FS_WKUP();
+    fn TIM8_BRK_TIM12();
+    fn TIM8_UP_TIM13();
+    fn TIM8_TRG_COM_TIM14();
+    fn TIM8_CC();
+    fn DMA1_STREAM7();
+    fn FSMC();
+    fn SDIO();
+    fn TIM5();
+    fn SPI3();
+    fn USART4();
+    fn UART5();
+    fn TIM6_GLB_IT_DAC1_DAC2();
+    fn TIM7();
+    fn DMA2_STREAM0();
+    fn DMA2_STREAM1();
+    fn DMA2_STREAM2();
+    fn DMA2_STREAM3();
+    fn DMA2_STREAM4();
+    fn DFSDM1_FLT0();
+    fn DFSDM1_FLT1();
+    fn CAN2_TX();
+    fn CAN2_RX0();
+    fn CAN2_RX1();
+    fn CAN2_SCE();
+    fn OTG_FS_USB();
+    fn DMA2_STREAM5();
+    fn DMA2_STREAM6();
+    fn DMA2_STREAM7();
+    fn USART6();
+    fn I2C3_EV();
+    fn I2C3_ER();
+    fn CAN3_TX();
+    fn CAN3_RX0();
+    fn CAN3_RX1();
+    fn CAN3_SCE();
+    fn CRYPTO();
+    fn RNG();
+    fn FPU();
+    fn USART7();
+    fn USART8();
+    fn SPI4();
+    fn SPI5();
+    fn SAI1();
+    fn UART9();
+    fn UART10();
+    fn QUADSPI();
+    fn I2CFMP1EVENT();
+    fn I2CFMP1ERROR();
+    fn LPTIM1_OR_IT_EIT_23();
+    fn DFSDM2_FILTER1();
+    fn DFSDM2_FILTER2();
+    fn DFSDM2_FILTER3();
+    fn DFSDM2_FILTER4();
+}
 #[doc(hidden)]
-pub mod interrupt {
-    use bare_metal::Nr;
-    #[cfg(all(target_arch = "arm", feature = "rt"))]
-    global_asm!(
-        "
-                    .thumb_func
-                    DH_TRAMPOLINE:
-                        b DEFAULT_HANDLER
-                    "
-    );
-    #[doc = r" Hack to compile on x86"]
-    #[cfg(all(target_arch = "x86_64", feature = "rt"))]
-    global_asm!(
-        "
-                    DH_TRAMPOLINE:
-                        jmp DEFAULT_HANDLER
-                    "
-    );
-    #[cfg(feature = "rt")]
-    global_asm ! ( "\n.weak WWDG\nWWDG = DH_TRAMPOLINE\n.weak PVD\nPVD = DH_TRAMPOLINE\n.weak TAMP_STAMP\nTAMP_STAMP = DH_TRAMPOLINE\n.weak RTC_WKUP\nRTC_WKUP = DH_TRAMPOLINE\n.weak FLASH\nFLASH = DH_TRAMPOLINE\n.weak RCC\nRCC = DH_TRAMPOLINE\n.weak EXTI0\nEXTI0 = DH_TRAMPOLINE\n.weak EXTI1\nEXTI1 = DH_TRAMPOLINE\n.weak EXTI2\nEXTI2 = DH_TRAMPOLINE\n.weak EXTI3\nEXTI3 = DH_TRAMPOLINE\n.weak EXTI4\nEXTI4 = DH_TRAMPOLINE\n.weak DMA1_STREAM0\nDMA1_STREAM0 = DH_TRAMPOLINE\n.weak DMA1_STREAM1\nDMA1_STREAM1 = DH_TRAMPOLINE\n.weak DMA1_STREAM2\nDMA1_STREAM2 = DH_TRAMPOLINE\n.weak DMA1_STREAM3\nDMA1_STREAM3 = DH_TRAMPOLINE\n.weak DMA1_STREAM4\nDMA1_STREAM4 = DH_TRAMPOLINE\n.weak DMA1_STREAM5\nDMA1_STREAM5 = DH_TRAMPOLINE\n.weak DMA1_STREAM6\nDMA1_STREAM6 = DH_TRAMPOLINE\n.weak ADC\nADC = DH_TRAMPOLINE\n.weak CAN1_TX\nCAN1_TX = DH_TRAMPOLINE\n.weak CAN1_RX0\nCAN1_RX0 = DH_TRAMPOLINE\n.weak CAN1_RX1\nCAN1_RX1 = DH_TRAMPOLINE\n.weak CAN1_SCE\nCAN1_SCE = DH_TRAMPOLINE\n.weak EXTI9_5\nEXTI9_5 = DH_TRAMPOLINE\n.weak TIM1_BRK_TIM9\nTIM1_BRK_TIM9 = DH_TRAMPOLINE\n.weak TIM1_UP_TIM10\nTIM1_UP_TIM10 = DH_TRAMPOLINE\n.weak TIM1_TRG_COM_TIM11\nTIM1_TRG_COM_TIM11 = DH_TRAMPOLINE\n.weak TIM1_CC\nTIM1_CC = DH_TRAMPOLINE\n.weak TIM2\nTIM2 = DH_TRAMPOLINE\n.weak TIM3\nTIM3 = DH_TRAMPOLINE\n.weak TIM4\nTIM4 = DH_TRAMPOLINE\n.weak I2C1_EVT\nI2C1_EVT = DH_TRAMPOLINE\n.weak I2C1_ERR\nI2C1_ERR = DH_TRAMPOLINE\n.weak I2C2_EVT\nI2C2_EVT = DH_TRAMPOLINE\n.weak I2C2_ERR\nI2C2_ERR = DH_TRAMPOLINE\n.weak SPI1\nSPI1 = DH_TRAMPOLINE\n.weak SPI2\nSPI2 = DH_TRAMPOLINE\n.weak USART1\nUSART1 = DH_TRAMPOLINE\n.weak USART2\nUSART2 = DH_TRAMPOLINE\n.weak USART3\nUSART3 = DH_TRAMPOLINE\n.weak EXTI15_10\nEXTI15_10 = DH_TRAMPOLINE\n.weak EXTI17_RTC_ALARM\nEXTI17_RTC_ALARM = DH_TRAMPOLINE\n.weak EXTI18_OTG_FS_WKUP\nEXTI18_OTG_FS_WKUP = DH_TRAMPOLINE\n.weak TIM8_BRK_TIM12\nTIM8_BRK_TIM12 = DH_TRAMPOLINE\n.weak TIM8_UP_TIM13\nTIM8_UP_TIM13 = DH_TRAMPOLINE\n.weak TIM8_TRG_COM_TIM14\nTIM8_TRG_COM_TIM14 = DH_TRAMPOLINE\n.weak TIM8_CC\nTIM8_CC = DH_TRAMPOLINE\n.weak DMA1_STREAM7\nDMA1_STREAM7 = DH_TRAMPOLINE\n.weak FSMC\nFSMC = DH_TRAMPOLINE\n.weak SDIO\nSDIO = DH_TRAMPOLINE\n.weak TIM5\nTIM5 = DH_TRAMPOLINE\n.weak SPI3\nSPI3 = DH_TRAMPOLINE\n.weak USART4\nUSART4 = DH_TRAMPOLINE\n.weak UART5\nUART5 = DH_TRAMPOLINE\n.weak TIM6_GLB_IT_DAC1_DAC2\nTIM6_GLB_IT_DAC1_DAC2 = DH_TRAMPOLINE\n.weak TIM7\nTIM7 = DH_TRAMPOLINE\n.weak DMA2_STREAM0\nDMA2_STREAM0 = DH_TRAMPOLINE\n.weak DMA2_STREAM1\nDMA2_STREAM1 = DH_TRAMPOLINE\n.weak DMA2_STREAM2\nDMA2_STREAM2 = DH_TRAMPOLINE\n.weak DMA2_STREAM3\nDMA2_STREAM3 = DH_TRAMPOLINE\n.weak DMA2_STREAM4\nDMA2_STREAM4 = DH_TRAMPOLINE\n.weak DFSDM1_FLT0\nDFSDM1_FLT0 = DH_TRAMPOLINE\n.weak DFSDM1_FLT1\nDFSDM1_FLT1 = DH_TRAMPOLINE\n.weak CAN2_TX\nCAN2_TX = DH_TRAMPOLINE\n.weak CAN2_RX0\nCAN2_RX0 = DH_TRAMPOLINE\n.weak CAN2_RX1\nCAN2_RX1 = DH_TRAMPOLINE\n.weak CAN2_SCE\nCAN2_SCE = DH_TRAMPOLINE\n.weak OTG_FS_USB\nOTG_FS_USB = DH_TRAMPOLINE\n.weak DMA2_STREAM5\nDMA2_STREAM5 = DH_TRAMPOLINE\n.weak DMA2_STREAM6\nDMA2_STREAM6 = DH_TRAMPOLINE\n.weak DMA2_STREAM7\nDMA2_STREAM7 = DH_TRAMPOLINE\n.weak USART6\nUSART6 = DH_TRAMPOLINE\n.weak I2C3_EV\nI2C3_EV = DH_TRAMPOLINE\n.weak I2C3_ER\nI2C3_ER = DH_TRAMPOLINE\n.weak CAN3_TX\nCAN3_TX = DH_TRAMPOLINE\n.weak CAN3_RX0\nCAN3_RX0 = DH_TRAMPOLINE\n.weak CAN3_RX1\nCAN3_RX1 = DH_TRAMPOLINE\n.weak CAN3_SCE\nCAN3_SCE = DH_TRAMPOLINE\n.weak CRYPTO\nCRYPTO = DH_TRAMPOLINE\n.weak RNG\nRNG = DH_TRAMPOLINE\n.weak FPU\nFPU = DH_TRAMPOLINE\n.weak USART7\nUSART7 = DH_TRAMPOLINE\n.weak USART8\nUSART8 = DH_TRAMPOLINE\n.weak SPI4\nSPI4 = DH_TRAMPOLINE\n.weak SPI5\nSPI5 = DH_TRAMPOLINE\n.weak SAI1\nSAI1 = DH_TRAMPOLINE\n.weak UART9\nUART9 = DH_TRAMPOLINE\n.weak UART10\nUART10 = DH_TRAMPOLINE\n.weak QUADSPI\nQUADSPI = DH_TRAMPOLINE\n.weak I2CFMP1EVENT\nI2CFMP1EVENT = DH_TRAMPOLINE\n.weak I2CFMP1ERROR\nI2CFMP1ERROR = DH_TRAMPOLINE\n.weak LPTIM1_OR_IT_EIT_23\nLPTIM1_OR_IT_EIT_23 = DH_TRAMPOLINE\n.weak DFSDM2_FILTER1\nDFSDM2_FILTER1 = DH_TRAMPOLINE\n.weak DFSDM2_FILTER2\nDFSDM2_FILTER2 = DH_TRAMPOLINE\n.weak DFSDM2_FILTER3\nDFSDM2_FILTER3 = DH_TRAMPOLINE\n.weak DFSDM2_FILTER4\nDFSDM2_FILTER4 = DH_TRAMPOLINE" ) ;
-    #[cfg(feature = "rt")]
-    extern "C" {
-        fn WWDG();
-        fn PVD();
-        fn TAMP_STAMP();
-        fn RTC_WKUP();
-        fn FLASH();
-        fn RCC();
-        fn EXTI0();
-        fn EXTI1();
-        fn EXTI2();
-        fn EXTI3();
-        fn EXTI4();
-        fn DMA1_STREAM0();
-        fn DMA1_STREAM1();
-        fn DMA1_STREAM2();
-        fn DMA1_STREAM3();
-        fn DMA1_STREAM4();
-        fn DMA1_STREAM5();
-        fn DMA1_STREAM6();
-        fn ADC();
-        fn CAN1_TX();
-        fn CAN1_RX0();
-        fn CAN1_RX1();
-        fn CAN1_SCE();
-        fn EXTI9_5();
-        fn TIM1_BRK_TIM9();
-        fn TIM1_UP_TIM10();
-        fn TIM1_TRG_COM_TIM11();
-        fn TIM1_CC();
-        fn TIM2();
-        fn TIM3();
-        fn TIM4();
-        fn I2C1_EVT();
-        fn I2C1_ERR();
-        fn I2C2_EVT();
-        fn I2C2_ERR();
-        fn SPI1();
-        fn SPI2();
-        fn USART1();
-        fn USART2();
-        fn USART3();
-        fn EXTI15_10();
-        fn EXTI17_RTC_ALARM();
-        fn EXTI18_OTG_FS_WKUP();
-        fn TIM8_BRK_TIM12();
-        fn TIM8_UP_TIM13();
-        fn TIM8_TRG_COM_TIM14();
-        fn TIM8_CC();
-        fn DMA1_STREAM7();
-        fn FSMC();
-        fn SDIO();
-        fn TIM5();
-        fn SPI3();
-        fn USART4();
-        fn UART5();
-        fn TIM6_GLB_IT_DAC1_DAC2();
-        fn TIM7();
-        fn DMA2_STREAM0();
-        fn DMA2_STREAM1();
-        fn DMA2_STREAM2();
-        fn DMA2_STREAM3();
-        fn DMA2_STREAM4();
-        fn DFSDM1_FLT0();
-        fn DFSDM1_FLT1();
-        fn CAN2_TX();
-        fn CAN2_RX0();
-        fn CAN2_RX1();
-        fn CAN2_SCE();
-        fn OTG_FS_USB();
-        fn DMA2_STREAM5();
-        fn DMA2_STREAM6();
-        fn DMA2_STREAM7();
-        fn USART6();
-        fn I2C3_EV();
-        fn I2C3_ER();
-        fn CAN3_TX();
-        fn CAN3_RX0();
-        fn CAN3_RX1();
-        fn CAN3_SCE();
-        fn CRYPTO();
-        fn RNG();
-        fn FPU();
-        fn USART7();
-        fn USART8();
-        fn SPI4();
-        fn SPI5();
-        fn SAI1();
-        fn UART9();
-        fn UART10();
-        fn QUADSPI();
-        fn I2CFMP1EVENT();
-        fn I2CFMP1ERROR();
-        fn LPTIM1_OR_IT_EIT_23();
-        fn DFSDM2_FILTER1();
-        fn DFSDM2_FILTER2();
-        fn DFSDM2_FILTER3();
-        fn DFSDM2_FILTER4();
-    }
-    #[allow(private_no_mangle_statics)]
-    #[cfg(feature = "rt")]
-    #[doc(hidden)]
-    #[link_section = ".vector_table.interrupts"]
-    #[no_mangle]
-    #[used]
-    pub static INTERRUPTS: [Option<unsafe extern "C" fn()>; 102] = [
-        Some(WWDG),
-        Some(PVD),
-        Some(TAMP_STAMP),
-        Some(RTC_WKUP),
-        Some(FLASH),
-        Some(RCC),
-        Some(EXTI0),
-        Some(EXTI1),
-        Some(EXTI2),
-        Some(EXTI3),
-        Some(EXTI4),
-        Some(DMA1_STREAM0),
-        Some(DMA1_STREAM1),
-        Some(DMA1_STREAM2),
-        Some(DMA1_STREAM3),
-        Some(DMA1_STREAM4),
-        Some(DMA1_STREAM5),
-        Some(DMA1_STREAM6),
-        Some(ADC),
-        Some(CAN1_TX),
-        Some(CAN1_RX0),
-        Some(CAN1_RX1),
-        Some(CAN1_SCE),
-        Some(EXTI9_5),
-        Some(TIM1_BRK_TIM9),
-        Some(TIM1_UP_TIM10),
-        Some(TIM1_TRG_COM_TIM11),
-        Some(TIM1_CC),
-        Some(TIM2),
-        Some(TIM3),
-        Some(TIM4),
-        Some(I2C1_EVT),
-        Some(I2C1_ERR),
-        Some(I2C2_EVT),
-        Some(I2C2_ERR),
-        Some(SPI1),
-        Some(SPI2),
-        Some(USART1),
-        Some(USART2),
-        Some(USART3),
-        Some(EXTI15_10),
-        Some(EXTI17_RTC_ALARM),
-        Some(EXTI18_OTG_FS_WKUP),
-        Some(TIM8_BRK_TIM12),
-        Some(TIM8_UP_TIM13),
-        Some(TIM8_TRG_COM_TIM14),
-        Some(TIM8_CC),
-        Some(DMA1_STREAM7),
-        Some(FSMC),
-        Some(SDIO),
-        Some(TIM5),
-        Some(SPI3),
-        Some(USART4),
-        Some(UART5),
-        Some(TIM6_GLB_IT_DAC1_DAC2),
-        Some(TIM7),
-        Some(DMA2_STREAM0),
-        Some(DMA2_STREAM1),
-        Some(DMA2_STREAM2),
-        Some(DMA2_STREAM3),
-        Some(DMA2_STREAM4),
-        Some(DFSDM1_FLT0),
-        Some(DFSDM1_FLT1),
-        Some(CAN2_TX),
-        Some(CAN2_RX0),
-        Some(CAN2_RX1),
-        Some(CAN2_SCE),
-        Some(OTG_FS_USB),
-        Some(DMA2_STREAM5),
-        Some(DMA2_STREAM6),
-        Some(DMA2_STREAM7),
-        Some(USART6),
-        Some(I2C3_EV),
-        Some(I2C3_ER),
-        Some(CAN3_TX),
-        Some(CAN3_RX0),
-        Some(CAN3_RX1),
-        Some(CAN3_SCE),
-        None,
-        Some(CRYPTO),
-        Some(RNG),
-        Some(FPU),
-        Some(USART7),
-        Some(USART8),
-        Some(SPI4),
-        Some(SPI5),
-        None,
-        Some(SAI1),
-        Some(UART9),
-        Some(UART10),
-        None,
-        None,
-        Some(QUADSPI),
-        None,
-        None,
-        Some(I2CFMP1EVENT),
-        Some(I2CFMP1ERROR),
-        Some(LPTIM1_OR_IT_EIT_23),
-        Some(DFSDM2_FILTER1),
-        Some(DFSDM2_FILTER2),
-        Some(DFSDM2_FILTER3),
-        Some(DFSDM2_FILTER4),
-    ];
-    #[doc = r" Enumeration of all the interrupts"]
-    pub enum Interrupt {
-        #[doc = "0 - Window Watchdog interrupt"] WWDG,
-        #[doc = "1 - PVD through EXTI line detection interrupt"] PVD,
-        #[doc = "2 - Tamper and TimeStamp interrupts through the EXTI line"] TAMP_STAMP,
-        #[doc = "3 - RTC Wakeup interrupt through the EXTI line"] RTC_WKUP,
-        #[doc = "4 - FLASH global interrupt"] FLASH,
-        #[doc = "5 - RCC global interrupt"] RCC,
-        #[doc = "6 - EXTI Line0 interrupt"] EXTI0,
-        #[doc = "7 - EXTI Line1 interrupt"] EXTI1,
-        #[doc = "8 - EXTI Line2 interrupt"] EXTI2,
-        #[doc = "9 - EXTI Line3 interrupt"] EXTI3,
-        #[doc = "10 - EXTI Line4 interrupt"] EXTI4,
-        #[doc = "11 - DMA1 Stream0 global interrupt"] DMA1_STREAM0,
-        #[doc = "12 - DMA1 Stream1 global interrupt"] DMA1_STREAM1,
-        #[doc = "13 - DMA1 Stream2 global interrupt"] DMA1_STREAM2,
-        #[doc = "14 - DMA1 Stream3 global interrupt"] DMA1_STREAM3,
-        #[doc = "15 - DMA1 Stream4 global interrupt"] DMA1_STREAM4,
-        #[doc = "16 - DMA1 Stream5 global interrupt"] DMA1_STREAM5,
-        #[doc = "17 - DMA1 Stream6 global interrupt"] DMA1_STREAM6,
-        #[doc = "18 - ADC1 global interrupt"] ADC,
-        #[doc = "19 - CAN1 TX interrupts"] CAN1_TX,
-        #[doc = "20 - CAN1 RX0 interrupts"] CAN1_RX0,
-        #[doc = "21 - CAN1 RX1 interrupts"] CAN1_RX1,
-        #[doc = "22 - CAN1 SCE interrupt"] CAN1_SCE,
-        #[doc = "23 - EXTI Line[9:5] interrupts"] EXTI9_5,
-        #[doc = "24 - TIM1 Break interrupt and TIM9 global interrupt"] TIM1_BRK_TIM9,
-        #[doc = "25 - TIM1 Update interrupt and TIM10 global interrupt"] TIM1_UP_TIM10,
-        #[doc = "26 - TIM1 Trigger and Commutation interrupts and TIM11 global interrupt"]
-        TIM1_TRG_COM_TIM11,
-        #[doc = "27 - TIM1 Capture Compare interrupt"] TIM1_CC,
-        #[doc = "28 - TIM2 global interrupt"] TIM2,
-        #[doc = "29 - TIM3 global interrupt"] TIM3,
-        #[doc = "30 - TIM4 global interrupt"] TIM4,
-        #[doc = "31 - I2C1 event interrupt"] I2C1_EVT,
-        #[doc = "32 - I2C1 error interrupt"] I2C1_ERR,
-        #[doc = "33 - I2C2 event interrupt"] I2C2_EVT,
-        #[doc = "34 - I2C2 error interrupt"] I2C2_ERR,
-        #[doc = "35 - SPI1 global interrupt"] SPI1,
-        #[doc = "36 - SPI2 global interrupt"] SPI2,
-        #[doc = "37 - USART1 global interrupt"] USART1,
-        #[doc = "38 - USART2 global interrupt"] USART2,
-        #[doc = "39 - USART3 global interrupt"] USART3,
-        #[doc = "40 - EXTI Line[15:10] interrupts"] EXTI15_10,
-        #[doc = "41 - RTC Alarms (A and B) through EXTI line interrupt"] EXTI17_RTC_ALARM,
-        #[doc = "42 - USB On-The-Go FS Wakeup through EXTI line interrupt"] EXTI18_OTG_FS_WKUP,
-        #[doc = "43 - Timer 12 global interrupt"] TIM8_BRK_TIM12,
-        #[doc = "44 - Timer 13 global interrupt"] TIM8_UP_TIM13,
-        #[doc = "45 - Timer 14 global interrupt"] TIM8_TRG_COM_TIM14,
-        #[doc = "46 - TIM8 Cap/Com interrupt"] TIM8_CC,
-        #[doc = "47 - DMA1 global interrupt Channel 7"] DMA1_STREAM7,
-        #[doc = "48 - FSMC global interrupt"] FSMC,
-        #[doc = "49 - SDIO global interrupt"] SDIO,
-        #[doc = "50 - TIM5 global interrupt"] TIM5,
-        #[doc = "51 - SPI3 global interrupt"] SPI3,
-        #[doc = "52 - UART 4 global interrupt"] USART4,
-        #[doc = "53 - UART 5global interrupt"] UART5,
-        #[doc = "54 - TIM6 global and DAC12 underrun interrupts"] TIM6_GLB_IT_DAC1_DAC2,
-        #[doc = "55 - TIM7 global interrupt"] TIM7,
-        #[doc = "56 - DMA2 Stream0 global interrupt"] DMA2_STREAM0,
-        #[doc = "57 - DMA2 Stream1 global interrupt"] DMA2_STREAM1,
-        #[doc = "58 - DMA2 Stream2 global interrupt"] DMA2_STREAM2,
-        #[doc = "59 - DMA2 Stream3 global interrupt"] DMA2_STREAM3,
-        #[doc = "60 - DMA2 Stream4 global interrupt"] DMA2_STREAM4,
-        #[doc = "61 - SD filter0 global interrupt"] DFSDM1_FLT0,
-        #[doc = "62 - SD filter1 global interrupt"] DFSDM1_FLT1,
-        #[doc = "63 - CAN2 TX interrupt"] CAN2_TX,
-        #[doc = "64 - BXCAN2 RX0 interrupt"] CAN2_RX0,
-        #[doc = "65 - BXCAN2 RX1 interrupt"] CAN2_RX1,
-        #[doc = "66 - CAN2 SCE interrupt"] CAN2_SCE,
-        #[doc = "67 - USB On The Go FS global interrupt"] OTG_FS_USB,
-        #[doc = "68 - DMA2 Stream5 global interrupt"] DMA2_STREAM5,
-        #[doc = "69 - DMA2 Stream6 global interrupt"] DMA2_STREAM6,
-        #[doc = "70 - DMA2 Stream7 global interrupt"] DMA2_STREAM7,
-        #[doc = "71 - USART6 global interrupt"] USART6,
-        #[doc = "72 - I2C3 event interrupt"] I2C3_EV,
-        #[doc = "73 - I2C3 error interrupt"] I2C3_ER,
-        #[doc = "74 - CAN 3 TX interrupt"] CAN3_TX,
-        #[doc = "75 - BxCAN 3 RX0 interrupt"] CAN3_RX0,
-        #[doc = "76 - BxCAN 3 RX1 interrupt"] CAN3_RX1,
-        #[doc = "77 - CAN 3 SCE interrupt"] CAN3_SCE,
-        #[doc = "79 - AES global interrupt"] CRYPTO,
-        #[doc = "80 - Rng global interrupt"] RNG,
-        #[doc = "81 - FPU global interrupt"] FPU,
-        #[doc = "82 - USART7 global interrupt"] USART7,
-        #[doc = "83 - USART8 global interrupt"] USART8,
-        #[doc = "84 - SPI4 global interrupt"] SPI4,
-        #[doc = "85 - SPI5 global interrupt"] SPI5,
-        #[doc = "87 - SAI1 global interrupt"] SAI1,
-        #[doc = "88 - UART9 global interrupt"] UART9,
-        #[doc = "89 - UART10 global interrupt"] UART10,
-        #[doc = "92 - Quad-SPI global interrupt"] QUADSPI,
-        #[doc = "95 - I2CFMP1 event interrupt"] I2CFMP1EVENT,
-        #[doc = "96 - I2CFMP1 error interrupt"] I2CFMP1ERROR,
-        #[doc = "97 - LP Timer global interrupt or EXT1 interrupt line 23"] LPTIM1_OR_IT_EIT_23,
-        #[doc = "98 - DFSDM2 SD filter 1 global interrupt"] DFSDM2_FILTER1,
-        #[doc = "99 - DFSDM2 SD filter 2 global interrupt"] DFSDM2_FILTER2,
-        #[doc = "100 - DFSDM2 SD filter 3 global interrupt"] DFSDM2_FILTER3,
-        #[doc = "101 - DFSDM2 SD filter 4 global interrupt"] DFSDM2_FILTER4,
-    }
-    unsafe impl Nr for Interrupt {
-        #[inline]
-        fn nr(&self) -> u8 {
-            match *self {
-                Interrupt::WWDG => 0,
-                Interrupt::PVD => 1,
-                Interrupt::TAMP_STAMP => 2,
-                Interrupt::RTC_WKUP => 3,
-                Interrupt::FLASH => 4,
-                Interrupt::RCC => 5,
-                Interrupt::EXTI0 => 6,
-                Interrupt::EXTI1 => 7,
-                Interrupt::EXTI2 => 8,
-                Interrupt::EXTI3 => 9,
-                Interrupt::EXTI4 => 10,
-                Interrupt::DMA1_STREAM0 => 11,
-                Interrupt::DMA1_STREAM1 => 12,
-                Interrupt::DMA1_STREAM2 => 13,
-                Interrupt::DMA1_STREAM3 => 14,
-                Interrupt::DMA1_STREAM4 => 15,
-                Interrupt::DMA1_STREAM5 => 16,
-                Interrupt::DMA1_STREAM6 => 17,
-                Interrupt::ADC => 18,
-                Interrupt::CAN1_TX => 19,
-                Interrupt::CAN1_RX0 => 20,
-                Interrupt::CAN1_RX1 => 21,
-                Interrupt::CAN1_SCE => 22,
-                Interrupt::EXTI9_5 => 23,
-                Interrupt::TIM1_BRK_TIM9 => 24,
-                Interrupt::TIM1_UP_TIM10 => 25,
-                Interrupt::TIM1_TRG_COM_TIM11 => 26,
-                Interrupt::TIM1_CC => 27,
-                Interrupt::TIM2 => 28,
-                Interrupt::TIM3 => 29,
-                Interrupt::TIM4 => 30,
-                Interrupt::I2C1_EVT => 31,
-                Interrupt::I2C1_ERR => 32,
-                Interrupt::I2C2_EVT => 33,
-                Interrupt::I2C2_ERR => 34,
-                Interrupt::SPI1 => 35,
-                Interrupt::SPI2 => 36,
-                Interrupt::USART1 => 37,
-                Interrupt::USART2 => 38,
-                Interrupt::USART3 => 39,
-                Interrupt::EXTI15_10 => 40,
-                Interrupt::EXTI17_RTC_ALARM => 41,
-                Interrupt::EXTI18_OTG_FS_WKUP => 42,
-                Interrupt::TIM8_BRK_TIM12 => 43,
-                Interrupt::TIM8_UP_TIM13 => 44,
-                Interrupt::TIM8_TRG_COM_TIM14 => 45,
-                Interrupt::TIM8_CC => 46,
-                Interrupt::DMA1_STREAM7 => 47,
-                Interrupt::FSMC => 48,
-                Interrupt::SDIO => 49,
-                Interrupt::TIM5 => 50,
-                Interrupt::SPI3 => 51,
-                Interrupt::USART4 => 52,
-                Interrupt::UART5 => 53,
-                Interrupt::TIM6_GLB_IT_DAC1_DAC2 => 54,
-                Interrupt::TIM7 => 55,
-                Interrupt::DMA2_STREAM0 => 56,
-                Interrupt::DMA2_STREAM1 => 57,
-                Interrupt::DMA2_STREAM2 => 58,
-                Interrupt::DMA2_STREAM3 => 59,
-                Interrupt::DMA2_STREAM4 => 60,
-                Interrupt::DFSDM1_FLT0 => 61,
-                Interrupt::DFSDM1_FLT1 => 62,
-                Interrupt::CAN2_TX => 63,
-                Interrupt::CAN2_RX0 => 64,
-                Interrupt::CAN2_RX1 => 65,
-                Interrupt::CAN2_SCE => 66,
-                Interrupt::OTG_FS_USB => 67,
-                Interrupt::DMA2_STREAM5 => 68,
-                Interrupt::DMA2_STREAM6 => 69,
-                Interrupt::DMA2_STREAM7 => 70,
-                Interrupt::USART6 => 71,
-                Interrupt::I2C3_EV => 72,
-                Interrupt::I2C3_ER => 73,
-                Interrupt::CAN3_TX => 74,
-                Interrupt::CAN3_RX0 => 75,
-                Interrupt::CAN3_RX1 => 76,
-                Interrupt::CAN3_SCE => 77,
-                Interrupt::CRYPTO => 79,
-                Interrupt::RNG => 80,
-                Interrupt::FPU => 81,
-                Interrupt::USART7 => 82,
-                Interrupt::USART8 => 83,
-                Interrupt::SPI4 => 84,
-                Interrupt::SPI5 => 85,
-                Interrupt::SAI1 => 87,
-                Interrupt::UART9 => 88,
-                Interrupt::UART10 => 89,
-                Interrupt::QUADSPI => 92,
-                Interrupt::I2CFMP1EVENT => 95,
-                Interrupt::I2CFMP1ERROR => 96,
-                Interrupt::LPTIM1_OR_IT_EIT_23 => 97,
-                Interrupt::DFSDM2_FILTER1 => 98,
-                Interrupt::DFSDM2_FILTER2 => 99,
-                Interrupt::DFSDM2_FILTER3 => 100,
-                Interrupt::DFSDM2_FILTER4 => 101,
-            }
+pub union Vector {
+    _handler: unsafe extern "C" fn(),
+    _reserved: u32,
+}
+#[cfg(feature = "rt")]
+#[doc(hidden)]
+#[link_section = ".vector_table.interrupts"]
+#[no_mangle]
+pub static __INTERRUPTS: [Vector; 102] = [
+    Vector { _handler: WWDG },
+    Vector { _handler: PVD },
+    Vector {
+        _handler: TAMP_STAMP,
+    },
+    Vector { _handler: RTC_WKUP },
+    Vector { _handler: FLASH },
+    Vector { _handler: RCC },
+    Vector { _handler: EXTI0 },
+    Vector { _handler: EXTI1 },
+    Vector { _handler: EXTI2 },
+    Vector { _handler: EXTI3 },
+    Vector { _handler: EXTI4 },
+    Vector {
+        _handler: DMA1_STREAM0,
+    },
+    Vector {
+        _handler: DMA1_STREAM1,
+    },
+    Vector {
+        _handler: DMA1_STREAM2,
+    },
+    Vector {
+        _handler: DMA1_STREAM3,
+    },
+    Vector {
+        _handler: DMA1_STREAM4,
+    },
+    Vector {
+        _handler: DMA1_STREAM5,
+    },
+    Vector {
+        _handler: DMA1_STREAM6,
+    },
+    Vector { _handler: ADC },
+    Vector { _handler: CAN1_TX },
+    Vector { _handler: CAN1_RX0 },
+    Vector { _handler: CAN1_RX1 },
+    Vector { _handler: CAN1_SCE },
+    Vector { _handler: EXTI9_5 },
+    Vector {
+        _handler: TIM1_BRK_TIM9,
+    },
+    Vector {
+        _handler: TIM1_UP_TIM10,
+    },
+    Vector {
+        _handler: TIM1_TRG_COM_TIM11,
+    },
+    Vector { _handler: TIM1_CC },
+    Vector { _handler: TIM2 },
+    Vector { _handler: TIM3 },
+    Vector { _handler: TIM4 },
+    Vector { _handler: I2C1_EVT },
+    Vector { _handler: I2C1_ERR },
+    Vector { _handler: I2C2_EVT },
+    Vector { _handler: I2C2_ERR },
+    Vector { _handler: SPI1 },
+    Vector { _handler: SPI2 },
+    Vector { _handler: USART1 },
+    Vector { _handler: USART2 },
+    Vector { _handler: USART3 },
+    Vector {
+        _handler: EXTI15_10,
+    },
+    Vector {
+        _handler: EXTI17_RTC_ALARM,
+    },
+    Vector {
+        _handler: EXTI18_OTG_FS_WKUP,
+    },
+    Vector {
+        _handler: TIM8_BRK_TIM12,
+    },
+    Vector {
+        _handler: TIM8_UP_TIM13,
+    },
+    Vector {
+        _handler: TIM8_TRG_COM_TIM14,
+    },
+    Vector { _handler: TIM8_CC },
+    Vector {
+        _handler: DMA1_STREAM7,
+    },
+    Vector { _handler: FSMC },
+    Vector { _handler: SDIO },
+    Vector { _handler: TIM5 },
+    Vector { _handler: SPI3 },
+    Vector { _handler: USART4 },
+    Vector { _handler: UART5 },
+    Vector {
+        _handler: TIM6_GLB_IT_DAC1_DAC2,
+    },
+    Vector { _handler: TIM7 },
+    Vector {
+        _handler: DMA2_STREAM0,
+    },
+    Vector {
+        _handler: DMA2_STREAM1,
+    },
+    Vector {
+        _handler: DMA2_STREAM2,
+    },
+    Vector {
+        _handler: DMA2_STREAM3,
+    },
+    Vector {
+        _handler: DMA2_STREAM4,
+    },
+    Vector {
+        _handler: DFSDM1_FLT0,
+    },
+    Vector {
+        _handler: DFSDM1_FLT1,
+    },
+    Vector { _handler: CAN2_TX },
+    Vector { _handler: CAN2_RX0 },
+    Vector { _handler: CAN2_RX1 },
+    Vector { _handler: CAN2_SCE },
+    Vector {
+        _handler: OTG_FS_USB,
+    },
+    Vector {
+        _handler: DMA2_STREAM5,
+    },
+    Vector {
+        _handler: DMA2_STREAM6,
+    },
+    Vector {
+        _handler: DMA2_STREAM7,
+    },
+    Vector { _handler: USART6 },
+    Vector { _handler: I2C3_EV },
+    Vector { _handler: I2C3_ER },
+    Vector { _handler: CAN3_TX },
+    Vector { _handler: CAN3_RX0 },
+    Vector { _handler: CAN3_RX1 },
+    Vector { _handler: CAN3_SCE },
+    Vector { _reserved: 0 },
+    Vector { _handler: CRYPTO },
+    Vector { _handler: RNG },
+    Vector { _handler: FPU },
+    Vector { _handler: USART7 },
+    Vector { _handler: USART8 },
+    Vector { _handler: SPI4 },
+    Vector { _handler: SPI5 },
+    Vector { _reserved: 0 },
+    Vector { _handler: SAI1 },
+    Vector { _handler: UART9 },
+    Vector { _handler: UART10 },
+    Vector { _reserved: 0 },
+    Vector { _reserved: 0 },
+    Vector { _handler: QUADSPI },
+    Vector { _reserved: 0 },
+    Vector { _reserved: 0 },
+    Vector {
+        _handler: I2CFMP1EVENT,
+    },
+    Vector {
+        _handler: I2CFMP1ERROR,
+    },
+    Vector {
+        _handler: LPTIM1_OR_IT_EIT_23,
+    },
+    Vector {
+        _handler: DFSDM2_FILTER1,
+    },
+    Vector {
+        _handler: DFSDM2_FILTER2,
+    },
+    Vector {
+        _handler: DFSDM2_FILTER3,
+    },
+    Vector {
+        _handler: DFSDM2_FILTER4,
+    },
+];
+#[doc = r" Macro to override a device specific interrupt handler"]
+#[doc = r""]
+#[doc = r" # Syntax"]
+#[doc = r""]
+#[doc = r" ``` ignore"]
+#[doc = r" interrupt!("]
+#[doc = r"     // Name of the interrupt"]
+#[doc = r"     $Name:ident,"]
+#[doc = r""]
+#[doc = r"     // Path to the interrupt handler (a function)"]
+#[doc = r"     $handler:path,"]
+#[doc = r""]
+#[doc = r"     // Optional, state preserved across invocations of the handler"]
+#[doc = r"     state: $State:ty = $initial_state:expr,"]
+#[doc = r" );"]
+#[doc = r" ```"]
+#[doc = r""]
+#[doc = r" Where `$Name` must match the name of one of the variants of the `Interrupt`"]
+#[doc = r" enum."]
+#[doc = r""]
+#[doc = r" The handler must have signature `fn()` is no state was associated to it;"]
+#[doc = r" otherwise its signature must be `fn(&mut $State)`."]
+#[cfg(feature = "rt")]
+#[macro_export]
+macro_rules! interrupt {
+    ( $ Name : ident , $ handler : path , state : $ State : ty = $ initial_state : expr ) => {
+        #[allow(unsafe_code)]
+        #[deny(private_no_mangle_fns)]
+        #[no_mangle]
+        pub unsafe extern "C" fn $Name() {
+            static mut STATE: $State = $initial_state;
+            let _ = $crate::Interrupt::$Name;
+            let f: fn(&mut $State) = $handler;
+            f(&mut STATE)
+        }
+    };
+    ( $ Name : ident , $ handler : path ) => {
+        #[allow(unsafe_code)]
+        #[deny(private_no_mangle_fns)]
+        #[no_mangle]
+        pub unsafe extern "C" fn $Name() {
+            let _ = $crate::Interrupt::$Name;
+            let f: fn() = $handler;
+            f()
+        }
+    };
+}
+#[doc = r" Enumeration of all the interrupts"]
+pub enum Interrupt {
+    #[doc = "0 - Window Watchdog interrupt"]
+    WWDG,
+    #[doc = "1 - PVD through EXTI line detection interrupt"]
+    PVD,
+    #[doc = "2 - Tamper and TimeStamp interrupts through the EXTI line"]
+    TAMP_STAMP,
+    #[doc = "3 - RTC Wakeup interrupt through the EXTI line"]
+    RTC_WKUP,
+    #[doc = "4 - FLASH global interrupt"]
+    FLASH,
+    #[doc = "5 - RCC global interrupt"]
+    RCC,
+    #[doc = "6 - EXTI Line0 interrupt"]
+    EXTI0,
+    #[doc = "7 - EXTI Line1 interrupt"]
+    EXTI1,
+    #[doc = "8 - EXTI Line2 interrupt"]
+    EXTI2,
+    #[doc = "9 - EXTI Line3 interrupt"]
+    EXTI3,
+    #[doc = "10 - EXTI Line4 interrupt"]
+    EXTI4,
+    #[doc = "11 - DMA1 Stream0 global interrupt"]
+    DMA1_STREAM0,
+    #[doc = "12 - DMA1 Stream1 global interrupt"]
+    DMA1_STREAM1,
+    #[doc = "13 - DMA1 Stream2 global interrupt"]
+    DMA1_STREAM2,
+    #[doc = "14 - DMA1 Stream3 global interrupt"]
+    DMA1_STREAM3,
+    #[doc = "15 - DMA1 Stream4 global interrupt"]
+    DMA1_STREAM4,
+    #[doc = "16 - DMA1 Stream5 global interrupt"]
+    DMA1_STREAM5,
+    #[doc = "17 - DMA1 Stream6 global interrupt"]
+    DMA1_STREAM6,
+    #[doc = "18 - ADC1 global interrupt"]
+    ADC,
+    #[doc = "19 - CAN1 TX interrupts"]
+    CAN1_TX,
+    #[doc = "20 - CAN1 RX0 interrupts"]
+    CAN1_RX0,
+    #[doc = "21 - CAN1 RX1 interrupts"]
+    CAN1_RX1,
+    #[doc = "22 - CAN1 SCE interrupt"]
+    CAN1_SCE,
+    #[doc = "23 - EXTI Line[9:5] interrupts"]
+    EXTI9_5,
+    #[doc = "24 - TIM1 Break interrupt and TIM9 global interrupt"]
+    TIM1_BRK_TIM9,
+    #[doc = "25 - TIM1 Update interrupt and TIM10 global interrupt"]
+    TIM1_UP_TIM10,
+    #[doc = "26 - TIM1 Trigger and Commutation interrupts and TIM11 global interrupt"]
+    TIM1_TRG_COM_TIM11,
+    #[doc = "27 - TIM1 Capture Compare interrupt"]
+    TIM1_CC,
+    #[doc = "28 - TIM2 global interrupt"]
+    TIM2,
+    #[doc = "29 - TIM3 global interrupt"]
+    TIM3,
+    #[doc = "30 - TIM4 global interrupt"]
+    TIM4,
+    #[doc = "31 - I2C1 event interrupt"]
+    I2C1_EVT,
+    #[doc = "32 - I2C1 error interrupt"]
+    I2C1_ERR,
+    #[doc = "33 - I2C2 event interrupt"]
+    I2C2_EVT,
+    #[doc = "34 - I2C2 error interrupt"]
+    I2C2_ERR,
+    #[doc = "35 - SPI1 global interrupt"]
+    SPI1,
+    #[doc = "36 - SPI2 global interrupt"]
+    SPI2,
+    #[doc = "37 - USART1 global interrupt"]
+    USART1,
+    #[doc = "38 - USART2 global interrupt"]
+    USART2,
+    #[doc = "39 - USART3 global interrupt"]
+    USART3,
+    #[doc = "40 - EXTI Line[15:10] interrupts"]
+    EXTI15_10,
+    #[doc = "41 - RTC Alarms (A and B) through EXTI line interrupt"]
+    EXTI17_RTC_ALARM,
+    #[doc = "42 - USB On-The-Go FS Wakeup through EXTI line interrupt"]
+    EXTI18_OTG_FS_WKUP,
+    #[doc = "43 - Timer 12 global interrupt"]
+    TIM8_BRK_TIM12,
+    #[doc = "44 - Timer 13 global interrupt"]
+    TIM8_UP_TIM13,
+    #[doc = "45 - Timer 14 global interrupt"]
+    TIM8_TRG_COM_TIM14,
+    #[doc = "46 - TIM8 Cap/Com interrupt"]
+    TIM8_CC,
+    #[doc = "47 - DMA1 global interrupt Channel 7"]
+    DMA1_STREAM7,
+    #[doc = "48 - FSMC global interrupt"]
+    FSMC,
+    #[doc = "49 - SDIO global interrupt"]
+    SDIO,
+    #[doc = "50 - TIM5 global interrupt"]
+    TIM5,
+    #[doc = "51 - SPI3 global interrupt"]
+    SPI3,
+    #[doc = "52 - UART 4 global interrupt"]
+    USART4,
+    #[doc = "53 - UART 5global interrupt"]
+    UART5,
+    #[doc = "54 - TIM6 global and DAC12 underrun interrupts"]
+    TIM6_GLB_IT_DAC1_DAC2,
+    #[doc = "55 - TIM7 global interrupt"]
+    TIM7,
+    #[doc = "56 - DMA2 Stream0 global interrupt"]
+    DMA2_STREAM0,
+    #[doc = "57 - DMA2 Stream1 global interrupt"]
+    DMA2_STREAM1,
+    #[doc = "58 - DMA2 Stream2 global interrupt"]
+    DMA2_STREAM2,
+    #[doc = "59 - DMA2 Stream3 global interrupt"]
+    DMA2_STREAM3,
+    #[doc = "60 - DMA2 Stream4 global interrupt"]
+    DMA2_STREAM4,
+    #[doc = "61 - SD filter0 global interrupt"]
+    DFSDM1_FLT0,
+    #[doc = "62 - SD filter1 global interrupt"]
+    DFSDM1_FLT1,
+    #[doc = "63 - CAN2 TX interrupt"]
+    CAN2_TX,
+    #[doc = "64 - BXCAN2 RX0 interrupt"]
+    CAN2_RX0,
+    #[doc = "65 - BXCAN2 RX1 interrupt"]
+    CAN2_RX1,
+    #[doc = "66 - CAN2 SCE interrupt"]
+    CAN2_SCE,
+    #[doc = "67 - USB On The Go FS global interrupt"]
+    OTG_FS_USB,
+    #[doc = "68 - DMA2 Stream5 global interrupt"]
+    DMA2_STREAM5,
+    #[doc = "69 - DMA2 Stream6 global interrupt"]
+    DMA2_STREAM6,
+    #[doc = "70 - DMA2 Stream7 global interrupt"]
+    DMA2_STREAM7,
+    #[doc = "71 - USART6 global interrupt"]
+    USART6,
+    #[doc = "72 - I2C3 event interrupt"]
+    I2C3_EV,
+    #[doc = "73 - I2C3 error interrupt"]
+    I2C3_ER,
+    #[doc = "74 - CAN 3 TX interrupt"]
+    CAN3_TX,
+    #[doc = "75 - BxCAN 3 RX0 interrupt"]
+    CAN3_RX0,
+    #[doc = "76 - BxCAN 3 RX1 interrupt"]
+    CAN3_RX1,
+    #[doc = "77 - CAN 3 SCE interrupt"]
+    CAN3_SCE,
+    #[doc = "79 - AES global interrupt"]
+    CRYPTO,
+    #[doc = "80 - Rng global interrupt"]
+    RNG,
+    #[doc = "81 - FPU global interrupt"]
+    FPU,
+    #[doc = "82 - USART7 global interrupt"]
+    USART7,
+    #[doc = "83 - USART8 global interrupt"]
+    USART8,
+    #[doc = "84 - SPI4 global interrupt"]
+    SPI4,
+    #[doc = "85 - SPI5 global interrupt"]
+    SPI5,
+    #[doc = "87 - SAI1 global interrupt"]
+    SAI1,
+    #[doc = "88 - UART9 global interrupt"]
+    UART9,
+    #[doc = "89 - UART10 global interrupt"]
+    UART10,
+    #[doc = "92 - Quad-SPI global interrupt"]
+    QUADSPI,
+    #[doc = "95 - I2CFMP1 event interrupt"]
+    I2CFMP1EVENT,
+    #[doc = "96 - I2CFMP1 error interrupt"]
+    I2CFMP1ERROR,
+    #[doc = "97 - LP Timer global interrupt or EXT1 interrupt line 23"]
+    LPTIM1_OR_IT_EIT_23,
+    #[doc = "98 - DFSDM2 SD filter 1 global interrupt"]
+    DFSDM2_FILTER1,
+    #[doc = "99 - DFSDM2 SD filter 2 global interrupt"]
+    DFSDM2_FILTER2,
+    #[doc = "100 - DFSDM2 SD filter 3 global interrupt"]
+    DFSDM2_FILTER3,
+    #[doc = "101 - DFSDM2 SD filter 4 global interrupt"]
+    DFSDM2_FILTER4,
+}
+unsafe impl ::bare_metal::Nr for Interrupt {
+    #[inline]
+    fn nr(&self) -> u8 {
+        match *self {
+            Interrupt::WWDG => 0,
+            Interrupt::PVD => 1,
+            Interrupt::TAMP_STAMP => 2,
+            Interrupt::RTC_WKUP => 3,
+            Interrupt::FLASH => 4,
+            Interrupt::RCC => 5,
+            Interrupt::EXTI0 => 6,
+            Interrupt::EXTI1 => 7,
+            Interrupt::EXTI2 => 8,
+            Interrupt::EXTI3 => 9,
+            Interrupt::EXTI4 => 10,
+            Interrupt::DMA1_STREAM0 => 11,
+            Interrupt::DMA1_STREAM1 => 12,
+            Interrupt::DMA1_STREAM2 => 13,
+            Interrupt::DMA1_STREAM3 => 14,
+            Interrupt::DMA1_STREAM4 => 15,
+            Interrupt::DMA1_STREAM5 => 16,
+            Interrupt::DMA1_STREAM6 => 17,
+            Interrupt::ADC => 18,
+            Interrupt::CAN1_TX => 19,
+            Interrupt::CAN1_RX0 => 20,
+            Interrupt::CAN1_RX1 => 21,
+            Interrupt::CAN1_SCE => 22,
+            Interrupt::EXTI9_5 => 23,
+            Interrupt::TIM1_BRK_TIM9 => 24,
+            Interrupt::TIM1_UP_TIM10 => 25,
+            Interrupt::TIM1_TRG_COM_TIM11 => 26,
+            Interrupt::TIM1_CC => 27,
+            Interrupt::TIM2 => 28,
+            Interrupt::TIM3 => 29,
+            Interrupt::TIM4 => 30,
+            Interrupt::I2C1_EVT => 31,
+            Interrupt::I2C1_ERR => 32,
+            Interrupt::I2C2_EVT => 33,
+            Interrupt::I2C2_ERR => 34,
+            Interrupt::SPI1 => 35,
+            Interrupt::SPI2 => 36,
+            Interrupt::USART1 => 37,
+            Interrupt::USART2 => 38,
+            Interrupt::USART3 => 39,
+            Interrupt::EXTI15_10 => 40,
+            Interrupt::EXTI17_RTC_ALARM => 41,
+            Interrupt::EXTI18_OTG_FS_WKUP => 42,
+            Interrupt::TIM8_BRK_TIM12 => 43,
+            Interrupt::TIM8_UP_TIM13 => 44,
+            Interrupt::TIM8_TRG_COM_TIM14 => 45,
+            Interrupt::TIM8_CC => 46,
+            Interrupt::DMA1_STREAM7 => 47,
+            Interrupt::FSMC => 48,
+            Interrupt::SDIO => 49,
+            Interrupt::TIM5 => 50,
+            Interrupt::SPI3 => 51,
+            Interrupt::USART4 => 52,
+            Interrupt::UART5 => 53,
+            Interrupt::TIM6_GLB_IT_DAC1_DAC2 => 54,
+            Interrupt::TIM7 => 55,
+            Interrupt::DMA2_STREAM0 => 56,
+            Interrupt::DMA2_STREAM1 => 57,
+            Interrupt::DMA2_STREAM2 => 58,
+            Interrupt::DMA2_STREAM3 => 59,
+            Interrupt::DMA2_STREAM4 => 60,
+            Interrupt::DFSDM1_FLT0 => 61,
+            Interrupt::DFSDM1_FLT1 => 62,
+            Interrupt::CAN2_TX => 63,
+            Interrupt::CAN2_RX0 => 64,
+            Interrupt::CAN2_RX1 => 65,
+            Interrupt::CAN2_SCE => 66,
+            Interrupt::OTG_FS_USB => 67,
+            Interrupt::DMA2_STREAM5 => 68,
+            Interrupt::DMA2_STREAM6 => 69,
+            Interrupt::DMA2_STREAM7 => 70,
+            Interrupt::USART6 => 71,
+            Interrupt::I2C3_EV => 72,
+            Interrupt::I2C3_ER => 73,
+            Interrupt::CAN3_TX => 74,
+            Interrupt::CAN3_RX0 => 75,
+            Interrupt::CAN3_RX1 => 76,
+            Interrupt::CAN3_SCE => 77,
+            Interrupt::CRYPTO => 79,
+            Interrupt::RNG => 80,
+            Interrupt::FPU => 81,
+            Interrupt::USART7 => 82,
+            Interrupt::USART8 => 83,
+            Interrupt::SPI4 => 84,
+            Interrupt::SPI5 => 85,
+            Interrupt::SAI1 => 87,
+            Interrupt::UART9 => 88,
+            Interrupt::UART10 => 89,
+            Interrupt::QUADSPI => 92,
+            Interrupt::I2CFMP1EVENT => 95,
+            Interrupt::I2CFMP1ERROR => 96,
+            Interrupt::LPTIM1_OR_IT_EIT_23 => 97,
+            Interrupt::DFSDM2_FILTER1 => 98,
+            Interrupt::DFSDM2_FILTER2 => 99,
+            Interrupt::DFSDM2_FILTER3 => 100,
+            Interrupt::DFSDM2_FILTER4 => 101,
         }
     }
-    #[cfg(feature = "rt")]
-    #[macro_export]
-    macro_rules ! interrupt { ( $ NAME : ident , $ path : path , locals : { $ ( $ lvar : ident : $ lty : ty = $ lval : expr ; ) * } ) => { # [ allow ( non_snake_case ) ] mod $ NAME { pub struct Locals { $ ( pub $ lvar : $ lty , ) * } } # [ allow ( non_snake_case ) ] # [ no_mangle ] pub extern "C" fn $ NAME ( ) { let _ = $ crate :: interrupt :: Interrupt :: $ NAME ; static mut LOCALS : self :: $ NAME :: Locals = self :: $ NAME :: Locals { $ ( $ lvar : $ lval , ) * } ; let f : fn ( & mut self :: $ NAME :: Locals ) = $ path ; f ( unsafe { & mut LOCALS } ) ; } } ; ( $ NAME : ident , $ path : path ) => { # [ allow ( non_snake_case ) ] # [ no_mangle ] pub extern "C" fn $ NAME ( ) { let _ = $ crate :: interrupt :: Interrupt :: $ NAME ; let f : fn ( ) = $ path ; f ( ) ; } } }
 }
+#[doc(hidden)]
+pub mod interrupt;
 pub use cortex_m::peripheral::Peripherals as CorePeripherals;
-pub use cortex_m::peripheral::CPUID;
-pub use cortex_m::peripheral::DCB;
-pub use cortex_m::peripheral::DWT;
-pub use cortex_m::peripheral::MPU;
-pub use cortex_m::peripheral::NVIC;
-pub use cortex_m::peripheral::SCB;
-pub use cortex_m::peripheral::SYST;
+pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
 #[doc = "Analog-to-digital converter"]
 pub struct ADC1 {
     _marker: PhantomData<*const ()>,
@@ -463,7 +655,7 @@ unsafe impl Send for ADC1 {}
 impl ADC1 {
     #[doc = r" Returns a pointer to the register block"]
     pub fn ptr() -> *const adc1::RegisterBlock {
-        0x4001_2000 as *const _
+        1073815552 as *const _
     }
 }
 impl Deref for ADC1 {
@@ -473,362614 +665,1333 @@ impl Deref for ADC1 {
     }
 }
 #[doc = "Analog-to-digital converter"]
-pub mod adc1 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - status register"]
-        pub sr: SR,
-        #[doc = "0x04 - control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x08 - control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x0c - sample time register 1"]
-        pub smpr1: SMPR1,
-        #[doc = "0x10 - sample time register 2"]
-        pub smpr2: SMPR2,
-        #[doc = "0x14 - injected channel data offset register x"]
-        pub jofr1: JOFR1,
-        #[doc = "0x18 - injected channel data offset register x"]
-        pub jofr2: JOFR2,
-        #[doc = "0x1c - injected channel data offset register x"]
-        pub jofr3: JOFR3,
-        #[doc = "0x20 - injected channel data offset register x"]
-        pub jofr4: JOFR4,
-        #[doc = "0x24 - watchdog higher threshold register"]
-        pub htr: HTR,
-        #[doc = "0x28 - watchdog lower threshold register"]
-        pub ltr: LTR,
-        #[doc = "0x2c - regular sequence register 1"]
-        pub sqr1: SQR1,
-        #[doc = "0x30 - regular sequence register 2"]
-        pub sqr2: SQR2,
-        #[doc = "0x34 - regular sequence register 3"]
-        pub sqr3: SQR3,
-        #[doc = "0x38 - injected sequence register"]
-        pub jsqr: JSQR,
-        #[doc = "0x3c - injected data register x"]
-        pub jdr1: JDR1,
-        #[doc = "0x40 - injected data register x"]
-        pub jdr2: JDR2,
-        #[doc = "0x44 - injected data register x"]
-        pub jdr3: JDR3,
-        #[doc = "0x48 - injected data register x"]
-        pub jdr4: JDR4,
-        #[doc = "0x4c - regular data register"]
-        pub dr: DR,
-        _reserved0: [u8; 688usize],
-        #[doc = "0x300 - Common status register"]
-        pub csr: CSR,
-        #[doc = "0x304 - common control register"]
-        pub ccr: CCR,
+pub mod adc1;
+#[doc = "Cryptographic processor"]
+pub struct CRC {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for CRC {}
+impl CRC {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const crc::RegisterBlock {
+        1073885184 as *const _
     }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
+}
+impl Deref for CRC {
+    type Target = crc::RegisterBlock;
+    fn deref(&self) -> &crc::RegisterBlock {
+        unsafe { &*CRC::ptr() }
     }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct OVRR {
-            bits: bool,
-        }
-        impl OVRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STRTR {
-            bits: bool,
-        }
-        impl STRTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSTRTR {
-            bits: bool,
-        }
-        impl JSTRTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCR {
-            bits: bool,
-        }
-        impl JEOCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EOCR {
-            bits: bool,
-        }
-        impl EOCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDR {
-            bits: bool,
-        }
-        impl AWDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OVRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STRTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STRTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSTRTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSTRTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEOCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEOCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EOCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EOCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 5 - Overrun"]
-            #[inline]
-            pub fn ovr(&self) -> OVRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRR { bits }
-            }
-            #[doc = "Bit 4 - Regular channel start flag"]
-            #[inline]
-            pub fn strt(&self) -> STRTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STRTR { bits }
-            }
-            #[doc = "Bit 3 - Injected channel start flag"]
-            #[inline]
-            pub fn jstrt(&self) -> JSTRTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSTRTR { bits }
-            }
-            #[doc = "Bit 2 - Injected channel end of conversion"]
-            #[inline]
-            pub fn jeoc(&self) -> JEOCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCR { bits }
-            }
-            #[doc = "Bit 1 - Regular channel end of conversion"]
-            #[inline]
-            pub fn eoc(&self) -> EOCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EOCR { bits }
-            }
-            #[doc = "Bit 0 - Analog watchdog flag"]
-            #[inline]
-            pub fn awd(&self) -> AWDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDR { bits }
-            }
-        }
-        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 5 - Overrun"]
-            #[inline]
-            pub fn ovr(&mut self) -> _OVRW {
-                _OVRW { w: self }
-            }
-            #[doc = "Bit 4 - Regular channel start flag"]
-            #[inline]
-            pub fn strt(&mut self) -> _STRTW {
-                _STRTW { w: self }
-            }
-            #[doc = "Bit 3 - Injected channel start flag"]
-            #[inline]
-            pub fn jstrt(&mut self) -> _JSTRTW {
-                _JSTRTW { w: self }
-            }
-            #[doc = "Bit 2 - Injected channel end of conversion"]
-            #[inline]
-            pub fn jeoc(&mut self) -> _JEOCW {
-                _JEOCW { w: self }
-            }
-            #[doc = "Bit 1 - Regular channel end of conversion"]
-            #[inline]
-            pub fn eoc(&mut self) -> _EOCW {
-                _EOCW { w: self }
-            }
-            #[doc = "Bit 0 - Analog watchdog flag"]
-            #[inline]
-            pub fn awd(&mut self) -> _AWDW {
-                _AWDW { w: self }
-            }
-        }
+}
+#[doc = "Cryptographic processor"]
+pub mod crc;
+#[doc = "Debug support"]
+pub struct DBG {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DBG {}
+impl DBG {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const dbg::RegisterBlock {
+        3758366720 as *const _
     }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
+}
+impl Deref for DBG {
+    type Target = dbg::RegisterBlock;
+    fn deref(&self) -> &dbg::RegisterBlock {
+        unsafe { &*DBG::ptr() }
     }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct OVRIER {
-            bits: bool,
-        }
-        impl OVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RESR {
-            bits: u8,
-        }
-        impl RESR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWDENR {
-            bits: bool,
-        }
-        impl AWDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JAWDENR {
-            bits: bool,
-        }
-        impl JAWDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DISCNUMR {
-            bits: u8,
-        }
-        impl DISCNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDISCENR {
-            bits: bool,
-        }
-        impl JDISCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DISCENR {
-            bits: bool,
-        }
-        impl DISCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JAUTOR {
-            bits: bool,
-        }
-        impl JAUTOR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDSGLR {
-            bits: bool,
-        }
-        impl AWDSGLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCANR {
-            bits: bool,
-        }
-        impl SCANR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCIER {
-            bits: bool,
-        }
-        impl JEOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDIER {
-            bits: bool,
-        }
-        impl AWDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EOCIER {
-            bits: bool,
-        }
-        impl EOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDCHR {
-            bits: u8,
-        }
-        impl AWDCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RESW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RESW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JAWDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JAWDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DISCNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DISCNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JDISCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JDISCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DISCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DISCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JAUTOW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JAUTOW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWDSGLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDSGLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCANW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCANW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEOCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EOCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWDCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 = "Bit 26 - Overrun interrupt enable"]
-            #[inline]
-            pub fn ovrie(&self) -> OVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRIER { bits }
-            }
-            #[doc = "Bits 24:25 - Resolution"]
-            #[inline]
-            pub fn res(&self) -> RESR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RESR { bits }
-            }
-            #[doc = "Bit 23 - Analog watchdog enable on regular channels"]
-            #[inline]
-            pub fn awden(&self) -> AWDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDENR { bits }
-            }
-            #[doc = "Bit 22 - Analog watchdog enable on injected channels"]
-            #[inline]
-            pub fn jawden(&self) -> JAWDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JAWDENR { bits }
-            }
-            #[doc = "Bits 13:15 - Discontinuous mode channel count"]
-            #[inline]
-            pub fn discnum(&self) -> DISCNUMR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DISCNUMR { bits }
-            }
-            #[doc = "Bit 12 - Discontinuous mode on injected channels"]
-            #[inline]
-            pub fn jdiscen(&self) -> JDISCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JDISCENR { bits }
-            }
-            #[doc = "Bit 11 - Discontinuous mode on regular channels"]
-            #[inline]
-            pub fn discen(&self) -> DISCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DISCENR { bits }
-            }
-            #[doc = "Bit 10 - Automatic injected group conversion"]
-            #[inline]
-            pub fn jauto(&self) -> JAUTOR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JAUTOR { bits }
-            }
-            #[doc = "Bit 9 - Enable the watchdog on a single channel in scan mode"]
-            #[inline]
-            pub fn awdsgl(&self) -> AWDSGLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDSGLR { bits }
-            }
-            #[doc = "Bit 8 - Scan mode"]
-            #[inline]
-            pub fn scan(&self) -> SCANR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCANR { bits }
-            }
-            #[doc = "Bit 7 - Interrupt enable for injected channels"]
-            #[inline]
-            pub fn jeocie(&self) -> JEOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCIER { bits }
-            }
-            #[doc = "Bit 6 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&self) -> AWDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDIER { bits }
-            }
-            #[doc = "Bit 5 - Interrupt enable for EOC"]
-            #[inline]
-            pub fn eocie(&self) -> EOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EOCIER { bits }
-            }
-            #[doc = "Bits 0:4 - Analog watchdog channel select bits"]
-            #[inline]
-            pub fn awdch(&self) -> AWDCHR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWDCHR { bits }
-            }
-        }
-        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 26 - Overrun interrupt enable"]
-            #[inline]
-            pub fn ovrie(&mut self) -> _OVRIEW {
-                _OVRIEW { w: self }
-            }
-            #[doc = "Bits 24:25 - Resolution"]
-            #[inline]
-            pub fn res(&mut self) -> _RESW {
-                _RESW { w: self }
-            }
-            #[doc = "Bit 23 - Analog watchdog enable on regular channels"]
-            #[inline]
-            pub fn awden(&mut self) -> _AWDENW {
-                _AWDENW { w: self }
-            }
-            #[doc = "Bit 22 - Analog watchdog enable on injected channels"]
-            #[inline]
-            pub fn jawden(&mut self) -> _JAWDENW {
-                _JAWDENW { w: self }
-            }
-            #[doc = "Bits 13:15 - Discontinuous mode channel count"]
-            #[inline]
-            pub fn discnum(&mut self) -> _DISCNUMW {
-                _DISCNUMW { w: self }
-            }
-            #[doc = "Bit 12 - Discontinuous mode on injected channels"]
-            #[inline]
-            pub fn jdiscen(&mut self) -> _JDISCENW {
-                _JDISCENW { w: self }
-            }
-            #[doc = "Bit 11 - Discontinuous mode on regular channels"]
-            #[inline]
-            pub fn discen(&mut self) -> _DISCENW {
-                _DISCENW { w: self }
-            }
-            #[doc = "Bit 10 - Automatic injected group conversion"]
-            #[inline]
-            pub fn jauto(&mut self) -> _JAUTOW {
-                _JAUTOW { w: self }
-            }
-            #[doc = "Bit 9 - Enable the watchdog on a single channel in scan mode"]
-            #[inline]
-            pub fn awdsgl(&mut self) -> _AWDSGLW {
-                _AWDSGLW { w: self }
-            }
-            #[doc = "Bit 8 - Scan mode"]
-            #[inline]
-            pub fn scan(&mut self) -> _SCANW {
-                _SCANW { w: self }
-            }
-            #[doc = "Bit 7 - Interrupt enable for injected channels"]
-            #[inline]
-            pub fn jeocie(&mut self) -> _JEOCIEW {
-                _JEOCIEW { w: self }
-            }
-            #[doc = "Bit 6 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&mut self) -> _AWDIEW {
-                _AWDIEW { w: self }
-            }
-            #[doc = "Bit 5 - Interrupt enable for EOC"]
-            #[inline]
-            pub fn eocie(&mut self) -> _EOCIEW {
-                _EOCIEW { w: self }
-            }
-            #[doc = "Bits 0:4 - Analog watchdog channel select bits"]
-            #[inline]
-            pub fn awdch(&mut self) -> _AWDCHW {
-                _AWDCHW { w: self }
-            }
-        }
+}
+#[doc = "Debug support"]
+pub mod dbg;
+#[doc = "External interrupt/event controller"]
+pub struct EXTI {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for EXTI {}
+impl EXTI {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const exti::RegisterBlock {
+        1073822720 as *const _
     }
-    #[doc = "control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
+}
+impl Deref for EXTI {
+    type Target = exti::RegisterBlock;
+    fn deref(&self) -> &exti::RegisterBlock {
+        unsafe { &*EXTI::ptr() }
     }
-    #[doc = "control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct SWSTARTR {
-            bits: bool,
-        }
-        impl SWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EXTENR {
-            bits: u8,
-        }
-        impl EXTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTSELR {
-            bits: u8,
-        }
-        impl EXTSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JSWSTARTR {
-            bits: bool,
-        }
-        impl JSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEXTENR {
-            bits: u8,
-        }
-        impl JEXTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JEXTSELR {
-            bits: u8,
-        }
-        impl JEXTSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ALIGNR {
-            bits: bool,
-        }
-        impl ALIGNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EOCSR {
-            bits: bool,
-        }
-        impl EOCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DDSR {
-            bits: bool,
-        }
-        impl DDSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAR {
-            bits: bool,
-        }
-        impl DMAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CONTR {
-            bits: bool,
-        }
-        impl CONTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADONR {
-            bits: bool,
-        }
-        impl ADONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EXTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEXTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JEXTSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ALIGNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALIGNW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EOCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EOCSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DDSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DDSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CONTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CONTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADONW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 30 - Start conversion of regular channels"]
-            #[inline]
-            pub fn swstart(&self) -> SWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWSTARTR { bits }
-            }
-            #[doc = "Bits 28:29 - External trigger enable for regular channels"]
-            #[inline]
-            pub fn exten(&self) -> EXTENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTENR { bits }
-            }
-            #[doc = "Bits 24:27 - External event select for regular group"]
-            #[inline]
-            pub fn extsel(&self) -> EXTSELR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTSELR { bits }
-            }
-            #[doc = "Bit 22 - Start conversion of injected channels"]
-            #[inline]
-            pub fn jswstart(&self) -> JSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSWSTARTR { bits }
-            }
-            #[doc = "Bits 20:21 - External trigger enable for injected channels"]
-            #[inline]
-            pub fn jexten(&self) -> JEXTENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTENR { bits }
-            }
-            #[doc = "Bits 16:19 - External event select for injected group"]
-            #[inline]
-            pub fn jextsel(&self) -> JEXTSELR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTSELR { bits }
-            }
-            #[doc = "Bit 11 - Data alignment"]
-            #[inline]
-            pub fn align(&self) -> ALIGNR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALIGNR { bits }
-            }
-            #[doc = "Bit 10 - End of conversion selection"]
-            #[inline]
-            pub fn eocs(&self) -> EOCSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EOCSR { bits }
-            }
-            #[doc = "Bit 9 - DMA disable selection (for single ADC mode)"]
-            #[inline]
-            pub fn dds(&self) -> DDSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DDSR { bits }
-            }
-            #[doc = "Bit 8 - Direct memory access mode (for single ADC mode)"]
-            #[inline]
-            pub fn dma(&self) -> DMAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAR { bits }
-            }
-            #[doc = "Bit 1 - Continuous conversion"]
-            #[inline]
-            pub fn cont(&self) -> CONTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CONTR { bits }
-            }
-            #[doc = "Bit 0 - A/D Converter ON / OFF"]
-            #[inline]
-            pub fn adon(&self) -> ADONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADONR { bits }
-            }
-        }
-        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 30 - Start conversion of regular channels"]
-            #[inline]
-            pub fn swstart(&mut self) -> _SWSTARTW {
-                _SWSTARTW { w: self }
-            }
-            #[doc = "Bits 28:29 - External trigger enable for regular channels"]
-            #[inline]
-            pub fn exten(&mut self) -> _EXTENW {
-                _EXTENW { w: self }
-            }
-            #[doc = "Bits 24:27 - External event select for regular group"]
-            #[inline]
-            pub fn extsel(&mut self) -> _EXTSELW {
-                _EXTSELW { w: self }
-            }
-            #[doc = "Bit 22 - Start conversion of injected channels"]
-            #[inline]
-            pub fn jswstart(&mut self) -> _JSWSTARTW {
-                _JSWSTARTW { w: self }
-            }
-            #[doc = "Bits 20:21 - External trigger enable for injected channels"]
-            #[inline]
-            pub fn jexten(&mut self) -> _JEXTENW {
-                _JEXTENW { w: self }
-            }
-            #[doc = "Bits 16:19 - External event select for injected group"]
-            #[inline]
-            pub fn jextsel(&mut self) -> _JEXTSELW {
-                _JEXTSELW { w: self }
-            }
-            #[doc = "Bit 11 - Data alignment"]
-            #[inline]
-            pub fn align(&mut self) -> _ALIGNW {
-                _ALIGNW { w: self }
-            }
-            #[doc = "Bit 10 - End of conversion selection"]
-            #[inline]
-            pub fn eocs(&mut self) -> _EOCSW {
-                _EOCSW { w: self }
-            }
-            #[doc = "Bit 9 - DMA disable selection (for single ADC mode)"]
-            #[inline]
-            pub fn dds(&mut self) -> _DDSW {
-                _DDSW { w: self }
-            }
-            #[doc = "Bit 8 - Direct memory access mode (for single ADC mode)"]
-            #[inline]
-            pub fn dma(&mut self) -> _DMAW {
-                _DMAW { w: self }
-            }
-            #[doc = "Bit 1 - Continuous conversion"]
-            #[inline]
-            pub fn cont(&mut self) -> _CONTW {
-                _CONTW { w: self }
-            }
-            #[doc = "Bit 0 - A/D Converter ON / OFF"]
-            #[inline]
-            pub fn adon(&mut self) -> _ADONW {
-                _ADONW { w: self }
-            }
-        }
+}
+#[doc = "External interrupt/event controller"]
+pub mod exti;
+#[doc = "FLASH"]
+pub struct FLASH {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for FLASH {}
+impl FLASH {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const flash::RegisterBlock {
+        1073888256 as *const _
     }
-    #[doc = "sample time register 1"]
-    pub struct SMPR1 {
-        register: VolatileCell<u32>,
+}
+impl Deref for FLASH {
+    type Target = flash::RegisterBlock;
+    fn deref(&self) -> &flash::RegisterBlock {
+        unsafe { &*FLASH::ptr() }
     }
-    #[doc = "sample time register 1"]
-    pub mod smpr1 {
-        #[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::SMPR1 {
-            #[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 = r" Value of the field"]
-        pub struct SMPX_XR {
-            bits: u32,
-        }
-        impl SMPX_XR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SMPX_XW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMPX_XW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Sample time bits"]
-            #[inline]
-            pub fn smpx_x(&self) -> SMPX_XR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                SMPX_XR { bits }
-            }
-        }
-        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 0:31 - Sample time bits"]
-            #[inline]
-            pub fn smpx_x(&mut self) -> _SMPX_XW {
-                _SMPX_XW { w: self }
-            }
-        }
+}
+#[doc = "FLASH"]
+pub mod flash;
+#[doc = "Independent watchdog"]
+pub struct IWDG {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for IWDG {}
+impl IWDG {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const iwdg::RegisterBlock {
+        1073754112 as *const _
     }
-    #[doc = "sample time register 2"]
-    pub struct SMPR2 {
-        register: VolatileCell<u32>,
+}
+impl Deref for IWDG {
+    type Target = iwdg::RegisterBlock;
+    fn deref(&self) -> &iwdg::RegisterBlock {
+        unsafe { &*IWDG::ptr() }
     }
-    #[doc = "sample time register 2"]
-    pub mod smpr2 {
-        #[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::SMPR2 {
-            #[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 = r" Value of the field"]
-        pub struct SMPX_XR {
-            bits: u32,
-        }
-        impl SMPX_XR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SMPX_XW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMPX_XW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Sample time bits"]
-            #[inline]
-            pub fn smpx_x(&self) -> SMPX_XR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                SMPX_XR { bits }
-            }
-        }
-        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 0:31 - Sample time bits"]
-            #[inline]
-            pub fn smpx_x(&mut self) -> _SMPX_XW {
-                _SMPX_XW { w: self }
-            }
-        }
-    }
-    #[doc = "injected channel data offset register x"]
-    pub struct JOFR1 {
-        register: VolatileCell<u32>,
+}
+#[doc = "Independent watchdog"]
+pub mod iwdg;
+#[doc = "Power control"]
+pub struct PWR {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for PWR {}
+impl PWR {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const pwr::RegisterBlock {
+        1073770496 as *const _
     }
-    #[doc = "injected channel data offset register x"]
-    pub mod jofr1 {
-        #[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::JOFR1 {
-            #[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 = r" Value of the field"]
-        pub struct JOFFSET1R {
-            bits: u16,
-        }
-        impl JOFFSET1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JOFFSET1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JOFFSET1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - Data offset for injected channel x"]
-            #[inline]
-            pub fn joffset1(&self) -> JOFFSET1R {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                JOFFSET1R { bits }
-            }
-        }
-        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 0:11 - Data offset for injected channel x"]
-            #[inline]
-            pub fn joffset1(&mut self) -> _JOFFSET1W {
-                _JOFFSET1W { w: self }
-            }
-        }
+}
+impl Deref for PWR {
+    type Target = pwr::RegisterBlock;
+    fn deref(&self) -> &pwr::RegisterBlock {
+        unsafe { &*PWR::ptr() }
     }
-    #[doc = "injected channel data offset register x"]
-    pub struct JOFR2 {
-        register: VolatileCell<u32>,
+}
+#[doc = "Power control"]
+pub mod pwr;
+#[doc = "Reset and clock control"]
+pub struct RCC {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for RCC {}
+impl RCC {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const rcc::RegisterBlock {
+        1073887232 as *const _
     }
-    #[doc = "injected channel data offset register x"]
-    pub mod jofr2 {
-        #[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::JOFR2 {
-            #[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 = r" Value of the field"]
-        pub struct JOFFSET2R {
-            bits: u16,
-        }
-        impl JOFFSET2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JOFFSET2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JOFFSET2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - Data offset for injected channel x"]
-            #[inline]
-            pub fn joffset2(&self) -> JOFFSET2R {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                JOFFSET2R { bits }
-            }
-        }
-        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 0:11 - Data offset for injected channel x"]
-            #[inline]
-            pub fn joffset2(&mut self) -> _JOFFSET2W {
-                _JOFFSET2W { w: self }
-            }
-        }
+}
+impl Deref for RCC {
+    type Target = rcc::RegisterBlock;
+    fn deref(&self) -> &rcc::RegisterBlock {
+        unsafe { &*RCC::ptr() }
     }
-    #[doc = "injected channel data offset register x"]
-    pub struct JOFR3 {
-        register: VolatileCell<u32>,
+}
+#[doc = "Reset and clock control"]
+pub mod rcc;
+#[doc = "Real-time clock"]
+pub struct RTC {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for RTC {}
+impl RTC {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const rtc::RegisterBlock {
+        1073752064 as *const _
     }
-    #[doc = "injected channel data offset register x"]
-    pub mod jofr3 {
-        #[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::JOFR3 {
-            #[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 = r" Value of the field"]
-        pub struct JOFFSET3R {
-            bits: u16,
-        }
-        impl JOFFSET3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JOFFSET3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JOFFSET3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - Data offset for injected channel x"]
-            #[inline]
-            pub fn joffset3(&self) -> JOFFSET3R {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                JOFFSET3R { bits }
-            }
-        }
-        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 0:11 - Data offset for injected channel x"]
-            #[inline]
-            pub fn joffset3(&mut self) -> _JOFFSET3W {
-                _JOFFSET3W { w: self }
-            }
-        }
+}
+impl Deref for RTC {
+    type Target = rtc::RegisterBlock;
+    fn deref(&self) -> &rtc::RegisterBlock {
+        unsafe { &*RTC::ptr() }
     }
-    #[doc = "injected channel data offset register x"]
-    pub struct JOFR4 {
-        register: VolatileCell<u32>,
+}
+#[doc = "Real-time clock"]
+pub mod rtc;
+#[doc = "Secure digital input/output interface"]
+pub struct SDIO {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SDIO {}
+impl SDIO {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const sdio::RegisterBlock {
+        1073818624 as *const _
     }
-    #[doc = "injected channel data offset register x"]
-    pub mod jofr4 {
-        #[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::JOFR4 {
-            #[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 = r" Value of the field"]
-        pub struct JOFFSET4R {
-            bits: u16,
-        }
-        impl JOFFSET4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JOFFSET4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JOFFSET4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - Data offset for injected channel x"]
-            #[inline]
-            pub fn joffset4(&self) -> JOFFSET4R {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                JOFFSET4R { bits }
-            }
-        }
-        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 0:11 - Data offset for injected channel x"]
-            #[inline]
-            pub fn joffset4(&mut self) -> _JOFFSET4W {
-                _JOFFSET4W { w: self }
-            }
-        }
+}
+impl Deref for SDIO {
+    type Target = sdio::RegisterBlock;
+    fn deref(&self) -> &sdio::RegisterBlock {
+        unsafe { &*SDIO::ptr() }
     }
-    #[doc = "watchdog higher threshold register"]
-    pub struct HTR {
-        register: VolatileCell<u32>,
+}
+#[doc = "Secure digital input/output interface"]
+pub mod sdio;
+#[doc = "System configuration controller"]
+pub struct SYSCFG {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SYSCFG {}
+impl SYSCFG {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const syscfg::RegisterBlock {
+        1073821696 as *const _
     }
-    #[doc = "watchdog higher threshold register"]
-    pub mod htr {
-        #[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::HTR {
-            #[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 = r" Value of the field"]
-        pub struct HTR {
-            bits: u16,
-        }
-        impl HTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - Analog watchdog higher threshold"]
-            #[inline]
-            pub fn ht(&self) -> HTR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                HTR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0fff }
-            }
-            #[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 0:11 - Analog watchdog higher threshold"]
-            #[inline]
-            pub fn ht(&mut self) -> _HTW {
-                _HTW { w: self }
-            }
-        }
+}
+impl Deref for SYSCFG {
+    type Target = syscfg::RegisterBlock;
+    fn deref(&self) -> &syscfg::RegisterBlock {
+        unsafe { &*SYSCFG::ptr() }
     }
-    #[doc = "watchdog lower threshold register"]
-    pub struct LTR {
-        register: VolatileCell<u32>,
+}
+#[doc = "System configuration controller"]
+pub mod syscfg;
+#[doc = "Advanced-timers"]
+pub struct TIM1 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM1 {}
+impl TIM1 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim1::RegisterBlock {
+        1073807360 as *const _
     }
-    #[doc = "watchdog lower threshold register"]
-    pub mod ltr {
-        #[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::LTR {
-            #[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 = r" Value of the field"]
-        pub struct LTR {
-            bits: u16,
-        }
-        impl LTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _LTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - Analog watchdog lower threshold"]
-            #[inline]
-            pub fn lt(&self) -> LTR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                LTR { bits }
-            }
-        }
-        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 0:11 - Analog watchdog lower threshold"]
-            #[inline]
-            pub fn lt(&mut self) -> _LTW {
-                _LTW { w: self }
-            }
-        }
+}
+impl Deref for TIM1 {
+    type Target = tim1::RegisterBlock;
+    fn deref(&self) -> &tim1::RegisterBlock {
+        unsafe { &*TIM1::ptr() }
     }
-    #[doc = "regular sequence register 1"]
-    pub struct SQR1 {
-        register: VolatileCell<u32>,
+}
+#[doc = "Advanced-timers"]
+pub mod tim1;
+#[doc = "TIM8"]
+pub struct TIM8 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM8 {}
+impl TIM8 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim1::RegisterBlock {
+        1073808384 as *const _
     }
-    #[doc = "regular sequence register 1"]
-    pub mod sqr1 {
-        #[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::SQR1 {
-            #[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 = r" Value of the field"]
-        pub struct LR {
-            bits: u8,
-        }
-        impl LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ16R {
-            bits: u8,
-        }
-        impl SQ16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ15R {
-            bits: u8,
-        }
-        impl SQ15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ14R {
-            bits: u8,
-        }
-        impl SQ14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ13R {
-            bits: u8,
-        }
-        impl SQ13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ16W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 15;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 20:23 - Regular channel sequence length"]
-            #[inline]
-            pub fn l(&self) -> LR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                LR { bits }
-            }
-            #[doc = "Bits 15:19 - 16th conversion in regular sequence"]
-            #[inline]
-            pub fn sq16(&self) -> SQ16R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ16R { bits }
-            }
-            #[doc = "Bits 10:14 - 15th conversion in regular sequence"]
-            #[inline]
-            pub fn sq15(&self) -> SQ15R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ15R { bits }
-            }
-            #[doc = "Bits 5:9 - 14th conversion in regular sequence"]
-            #[inline]
-            pub fn sq14(&self) -> SQ14R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ14R { bits }
-            }
-            #[doc = "Bits 0:4 - 13th conversion in regular sequence"]
-            #[inline]
-            pub fn sq13(&self) -> SQ13R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ13R { bits }
-            }
-        }
-        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 20:23 - Regular channel sequence length"]
-            #[inline]
-            pub fn l(&mut self) -> _LW {
-                _LW { w: self }
-            }
-            #[doc = "Bits 15:19 - 16th conversion in regular sequence"]
-            #[inline]
-            pub fn sq16(&mut self) -> _SQ16W {
-                _SQ16W { w: self }
-            }
-            #[doc = "Bits 10:14 - 15th conversion in regular sequence"]
-            #[inline]
-            pub fn sq15(&mut self) -> _SQ15W {
-                _SQ15W { w: self }
-            }
-            #[doc = "Bits 5:9 - 14th conversion in regular sequence"]
-            #[inline]
-            pub fn sq14(&mut self) -> _SQ14W {
-                _SQ14W { w: self }
-            }
-            #[doc = "Bits 0:4 - 13th conversion in regular sequence"]
-            #[inline]
-            pub fn sq13(&mut self) -> _SQ13W {
-                _SQ13W { w: self }
-            }
-        }
+}
+impl Deref for TIM8 {
+    type Target = tim1::RegisterBlock;
+    fn deref(&self) -> &tim1::RegisterBlock {
+        unsafe { &*TIM8::ptr() }
     }
-    #[doc = "regular sequence register 2"]
-    pub struct SQR2 {
-        register: VolatileCell<u32>,
+}
+#[doc = "General-purpose-timers"]
+pub struct TIM10 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM10 {}
+impl TIM10 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim10::RegisterBlock {
+        1073824768 as *const _
     }
-    #[doc = "regular sequence register 2"]
-    pub mod sqr2 {
-        #[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::SQR2 {
-            #[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 = r" Value of the field"]
-        pub struct SQ12R {
-            bits: u8,
-        }
-        impl SQ12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ11R {
-            bits: u8,
-        }
-        impl SQ11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ10R {
-            bits: u8,
-        }
-        impl SQ10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ9R {
-            bits: u8,
-        }
-        impl SQ9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ8R {
-            bits: u8,
-        }
-        impl SQ8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ7R {
-            bits: u8,
-        }
-        impl SQ7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 15;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 25:29 - 12th conversion in regular sequence"]
-            #[inline]
-            pub fn sq12(&self) -> SQ12R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ12R { bits }
-            }
-            #[doc = "Bits 20:24 - 11th conversion in regular sequence"]
-            #[inline]
-            pub fn sq11(&self) -> SQ11R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ11R { bits }
-            }
-            #[doc = "Bits 15:19 - 10th conversion in regular sequence"]
-            #[inline]
-            pub fn sq10(&self) -> SQ10R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ10R { bits }
-            }
-            #[doc = "Bits 10:14 - 9th conversion in regular sequence"]
-            #[inline]
-            pub fn sq9(&self) -> SQ9R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ9R { bits }
-            }
-            #[doc = "Bits 5:9 - 8th conversion in regular sequence"]
-            #[inline]
-            pub fn sq8(&self) -> SQ8R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ8R { bits }
-            }
-            #[doc = "Bits 0:4 - 7th conversion in regular sequence"]
-            #[inline]
-            pub fn sq7(&self) -> SQ7R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ7R { bits }
-            }
-        }
-        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 25:29 - 12th conversion in regular sequence"]
-            #[inline]
-            pub fn sq12(&mut self) -> _SQ12W {
-                _SQ12W { w: self }
-            }
-            #[doc = "Bits 20:24 - 11th conversion in regular sequence"]
-            #[inline]
-            pub fn sq11(&mut self) -> _SQ11W {
-                _SQ11W { w: self }
-            }
-            #[doc = "Bits 15:19 - 10th conversion in regular sequence"]
-            #[inline]
-            pub fn sq10(&mut self) -> _SQ10W {
-                _SQ10W { w: self }
-            }
-            #[doc = "Bits 10:14 - 9th conversion in regular sequence"]
-            #[inline]
-            pub fn sq9(&mut self) -> _SQ9W {
-                _SQ9W { w: self }
-            }
-            #[doc = "Bits 5:9 - 8th conversion in regular sequence"]
-            #[inline]
-            pub fn sq8(&mut self) -> _SQ8W {
-                _SQ8W { w: self }
-            }
-            #[doc = "Bits 0:4 - 7th conversion in regular sequence"]
-            #[inline]
-            pub fn sq7(&mut self) -> _SQ7W {
-                _SQ7W { w: self }
-            }
-        }
+}
+impl Deref for TIM10 {
+    type Target = tim10::RegisterBlock;
+    fn deref(&self) -> &tim10::RegisterBlock {
+        unsafe { &*TIM10::ptr() }
     }
-    #[doc = "regular sequence register 3"]
-    pub struct SQR3 {
-        register: VolatileCell<u32>,
+}
+#[doc = "General-purpose-timers"]
+pub mod tim10;
+#[doc = "General-purpose-timers"]
+pub struct TIM11 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM11 {}
+impl TIM11 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim11::RegisterBlock {
+        1073825792 as *const _
     }
-    #[doc = "regular sequence register 3"]
-    pub mod sqr3 {
-        #[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::SQR3 {
-            #[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 = r" Value of the field"]
-        pub struct SQ6R {
-            bits: u8,
-        }
-        impl SQ6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ5R {
-            bits: u8,
-        }
-        impl SQ5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ4R {
-            bits: u8,
-        }
-        impl SQ4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ3R {
-            bits: u8,
-        }
-        impl SQ3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ2R {
-            bits: u8,
-        }
-        impl SQ2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SQ1R {
-            bits: u8,
-        }
-        impl SQ1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 15;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SQ1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SQ1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 25:29 - 6th conversion in regular sequence"]
-            #[inline]
-            pub fn sq6(&self) -> SQ6R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ6R { bits }
-            }
-            #[doc = "Bits 20:24 - 5th conversion in regular sequence"]
-            #[inline]
-            pub fn sq5(&self) -> SQ5R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ5R { bits }
-            }
-            #[doc = "Bits 15:19 - 4th conversion in regular sequence"]
-            #[inline]
-            pub fn sq4(&self) -> SQ4R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ4R { bits }
-            }
-            #[doc = "Bits 10:14 - 3rd conversion in regular sequence"]
-            #[inline]
-            pub fn sq3(&self) -> SQ3R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ3R { bits }
-            }
-            #[doc = "Bits 5:9 - 2nd conversion in regular sequence"]
-            #[inline]
-            pub fn sq2(&self) -> SQ2R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ2R { bits }
-            }
-            #[doc = "Bits 0:4 - 1st conversion in regular sequence"]
-            #[inline]
-            pub fn sq1(&self) -> SQ1R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SQ1R { bits }
-            }
-        }
-        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 25:29 - 6th conversion in regular sequence"]
-            #[inline]
-            pub fn sq6(&mut self) -> _SQ6W {
-                _SQ6W { w: self }
-            }
-            #[doc = "Bits 20:24 - 5th conversion in regular sequence"]
-            #[inline]
-            pub fn sq5(&mut self) -> _SQ5W {
-                _SQ5W { w: self }
-            }
-            #[doc = "Bits 15:19 - 4th conversion in regular sequence"]
-            #[inline]
-            pub fn sq4(&mut self) -> _SQ4W {
-                _SQ4W { w: self }
-            }
-            #[doc = "Bits 10:14 - 3rd conversion in regular sequence"]
-            #[inline]
-            pub fn sq3(&mut self) -> _SQ3W {
-                _SQ3W { w: self }
-            }
-            #[doc = "Bits 5:9 - 2nd conversion in regular sequence"]
-            #[inline]
-            pub fn sq2(&mut self) -> _SQ2W {
-                _SQ2W { w: self }
-            }
-            #[doc = "Bits 0:4 - 1st conversion in regular sequence"]
-            #[inline]
-            pub fn sq1(&mut self) -> _SQ1W {
-                _SQ1W { w: self }
-            }
-        }
+}
+impl Deref for TIM11 {
+    type Target = tim11::RegisterBlock;
+    fn deref(&self) -> &tim11::RegisterBlock {
+        unsafe { &*TIM11::ptr() }
     }
-    #[doc = "injected sequence register"]
-    pub struct JSQR {
-        register: VolatileCell<u32>,
+}
+#[doc = "General-purpose-timers"]
+pub mod tim11;
+#[doc = "General purpose timers"]
+pub struct TIM2 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM2 {}
+impl TIM2 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim2::RegisterBlock {
+        1073741824 as *const _
     }
-    #[doc = "injected sequence register"]
-    pub mod jsqr {
-        #[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::JSQR {
-            #[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 = r" Value of the field"]
-        pub struct JLR {
-            bits: u8,
-        }
-        impl JLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JSQ4R {
-            bits: u8,
-        }
-        impl JSQ4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JSQ3R {
-            bits: u8,
-        }
-        impl JSQ3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JSQ2R {
-            bits: u8,
-        }
-        impl JSQ2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JSQ1R {
-            bits: u8,
-        }
-        impl JSQ1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JSQ4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSQ4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 15;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JSQ3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSQ3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JSQ2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSQ2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JSQ1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSQ1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 20:21 - Injected sequence length"]
-            #[inline]
-            pub fn jl(&self) -> JLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JLR { bits }
-            }
-            #[doc = "Bits 15:19 - 4th conversion in injected sequence"]
-            #[inline]
-            pub fn jsq4(&self) -> JSQ4R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JSQ4R { bits }
-            }
-            #[doc = "Bits 10:14 - 3rd conversion in injected sequence"]
-            #[inline]
-            pub fn jsq3(&self) -> JSQ3R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JSQ3R { bits }
-            }
-            #[doc = "Bits 5:9 - 2nd conversion in injected sequence"]
-            #[inline]
-            pub fn jsq2(&self) -> JSQ2R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JSQ2R { bits }
-            }
-            #[doc = "Bits 0:4 - 1st conversion in injected sequence"]
-            #[inline]
-            pub fn jsq1(&self) -> JSQ1R {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JSQ1R { bits }
-            }
-        }
-        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 20:21 - Injected sequence length"]
-            #[inline]
-            pub fn jl(&mut self) -> _JLW {
-                _JLW { w: self }
-            }
-            #[doc = "Bits 15:19 - 4th conversion in injected sequence"]
-            #[inline]
-            pub fn jsq4(&mut self) -> _JSQ4W {
-                _JSQ4W { w: self }
-            }
-            #[doc = "Bits 10:14 - 3rd conversion in injected sequence"]
-            #[inline]
-            pub fn jsq3(&mut self) -> _JSQ3W {
-                _JSQ3W { w: self }
-            }
-            #[doc = "Bits 5:9 - 2nd conversion in injected sequence"]
-            #[inline]
-            pub fn jsq2(&mut self) -> _JSQ2W {
-                _JSQ2W { w: self }
-            }
-            #[doc = "Bits 0:4 - 1st conversion in injected sequence"]
-            #[inline]
-            pub fn jsq1(&mut self) -> _JSQ1W {
-                _JSQ1W { w: self }
-            }
-        }
+}
+impl Deref for TIM2 {
+    type Target = tim2::RegisterBlock;
+    fn deref(&self) -> &tim2::RegisterBlock {
+        unsafe { &*TIM2::ptr() }
     }
-    #[doc = "injected data register x"]
-    pub struct JDR1 {
-        register: VolatileCell<u32>,
+}
+#[doc = "General purpose timers"]
+pub mod tim2;
+#[doc = "General purpose timers"]
+pub struct TIM3 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM3 {}
+impl TIM3 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim3::RegisterBlock {
+        1073742848 as *const _
     }
-    #[doc = "injected data register x"]
-    pub mod jdr1 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::JDR1 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATAR {
-            bits: u16,
-        }
-        impl JDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Injected data"]
-            #[inline]
-            pub fn jdata(&self) -> JDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                JDATAR { bits }
-            }
-        }
+}
+impl Deref for TIM3 {
+    type Target = tim3::RegisterBlock;
+    fn deref(&self) -> &tim3::RegisterBlock {
+        unsafe { &*TIM3::ptr() }
     }
-    #[doc = "injected data register x"]
-    pub struct JDR2 {
-        register: VolatileCell<u32>,
+}
+#[doc = "General purpose timers"]
+pub mod tim3;
+#[doc = "TIM4"]
+pub struct TIM4 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM4 {}
+impl TIM4 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim3::RegisterBlock {
+        1073743872 as *const _
     }
-    #[doc = "injected data register x"]
-    pub mod jdr2 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::JDR2 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATAR {
-            bits: u16,
-        }
-        impl JDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Injected data"]
-            #[inline]
-            pub fn jdata(&self) -> JDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                JDATAR { bits }
-            }
-        }
+}
+impl Deref for TIM4 {
+    type Target = tim3::RegisterBlock;
+    fn deref(&self) -> &tim3::RegisterBlock {
+        unsafe { &*TIM4::ptr() }
     }
-    #[doc = "injected data register x"]
-    pub struct JDR3 {
-        register: VolatileCell<u32>,
+}
+#[doc = "General-purpose-timers"]
+pub struct TIM5 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM5 {}
+impl TIM5 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim5::RegisterBlock {
+        1073744896 as *const _
     }
-    #[doc = "injected data register x"]
-    pub mod jdr3 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::JDR3 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATAR {
-            bits: u16,
-        }
-        impl JDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Injected data"]
-            #[inline]
-            pub fn jdata(&self) -> JDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                JDATAR { bits }
-            }
-        }
+}
+impl Deref for TIM5 {
+    type Target = tim5::RegisterBlock;
+    fn deref(&self) -> &tim5::RegisterBlock {
+        unsafe { &*TIM5::ptr() }
     }
-    #[doc = "injected data register x"]
-    pub struct JDR4 {
-        register: VolatileCell<u32>,
+}
+#[doc = "General-purpose-timers"]
+pub mod tim5;
+#[doc = "General purpose timers"]
+pub struct TIM9 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM9 {}
+impl TIM9 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim9::RegisterBlock {
+        1073823744 as *const _
     }
-    #[doc = "injected data register x"]
-    pub mod jdr4 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::JDR4 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATAR {
-            bits: u16,
-        }
-        impl JDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Injected data"]
-            #[inline]
-            pub fn jdata(&self) -> JDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                JDATAR { bits }
-            }
-        }
+}
+impl Deref for TIM9 {
+    type Target = tim9::RegisterBlock;
+    fn deref(&self) -> &tim9::RegisterBlock {
+        unsafe { &*TIM9::ptr() }
     }
-    #[doc = "regular data register"]
-    pub struct DR {
-        register: VolatileCell<u32>,
+}
+#[doc = "General purpose timers"]
+pub mod tim9;
+#[doc = "Universal synchronous asynchronous receiver transmitter"]
+pub struct USART1 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for USART1 {}
+impl USART1 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073811456 as *const _
     }
-    #[doc = "regular data register"]
-    pub mod dr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATAR {
-            bits: u16,
-        }
-        impl DATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Regular data"]
-            #[inline]
-            pub fn data(&self) -> DATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DATAR { bits }
-            }
-        }
+}
+impl Deref for USART1 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*USART1::ptr() }
     }
-    #[doc = "Common status register"]
-    pub struct CSR {
-        register: VolatileCell<u32>,
+}
+#[doc = "Universal synchronous asynchronous receiver transmitter"]
+pub mod usart1;
+#[doc = "USART2"]
+pub struct USART2 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for USART2 {}
+impl USART2 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073759232 as *const _
     }
-    #[doc = "Common status register"]
-    pub mod csr {
-        #[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::CSR {
-            #[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 = r" Value of the field"]
-        pub struct AWD1R {
-            bits: bool,
-        }
-        impl AWD1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EOC1R {
-            bits: bool,
-        }
-        impl EOC1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOC1R {
-            bits: bool,
-        }
-        impl JEOC1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSTRT1R {
-            bits: bool,
-        }
-        impl JSTRT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STRT1R {
-            bits: bool,
-        }
-        impl STRT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVR1R {
-            bits: bool,
-        }
-        impl OVR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWD1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWD1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EOC1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EOC1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEOC1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEOC1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSTRT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSTRT1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STRT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STRT1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OVR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVR1W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Analog watchdog flag of ADC1"]
-            #[inline]
-            pub fn awd1(&self) -> AWD1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWD1R { bits }
-            }
-            #[doc = "Bit 1 - End of conversion of ADC1"]
-            #[inline]
-            pub fn eoc1(&self) -> EOC1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EOC1R { bits }
-            }
-            #[doc = "Bit 2 - Injected channel end of conversion of ADC1"]
-            #[inline]
-            pub fn jeoc1(&self) -> JEOC1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOC1R { bits }
-            }
-            #[doc = "Bit 3 - Injected channel Start flag of ADC1"]
-            #[inline]
-            pub fn jstrt1(&self) -> JSTRT1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSTRT1R { bits }
-            }
-            #[doc = "Bit 4 - Regular channel Start flag of ADC1"]
-            #[inline]
-            pub fn strt1(&self) -> STRT1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STRT1R { bits }
-            }
-            #[doc = "Bit 5 - Overrun flag of ADC1"]
-            #[inline]
-            pub fn ovr1(&self) -> OVR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVR1R { bits }
-            }
-        }
-        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 - Analog watchdog flag of ADC1"]
-            #[inline]
-            pub fn awd1(&mut self) -> _AWD1W {
-                _AWD1W { w: self }
-            }
-            #[doc = "Bit 1 - End of conversion of ADC1"]
-            #[inline]
-            pub fn eoc1(&mut self) -> _EOC1W {
-                _EOC1W { w: self }
-            }
-            #[doc = "Bit 2 - Injected channel end of conversion of ADC1"]
-            #[inline]
-            pub fn jeoc1(&mut self) -> _JEOC1W {
-                _JEOC1W { w: self }
-            }
-            #[doc = "Bit 3 - Injected channel Start flag of ADC1"]
-            #[inline]
-            pub fn jstrt1(&mut self) -> _JSTRT1W {
-                _JSTRT1W { w: self }
-            }
-            #[doc = "Bit 4 - Regular channel Start flag of ADC1"]
-            #[inline]
-            pub fn strt1(&mut self) -> _STRT1W {
-                _STRT1W { w: self }
-            }
-            #[doc = "Bit 5 - Overrun flag of ADC1"]
-            #[inline]
-            pub fn ovr1(&mut self) -> _OVR1W {
-                _OVR1W { w: self }
-            }
-        }
+}
+impl Deref for USART2 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*USART2::ptr() }
     }
-    #[doc = "common control register"]
-    pub struct CCR {
-        register: VolatileCell<u32>,
+}
+#[doc = "USART6"]
+pub struct USART6 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for USART6 {}
+impl USART6 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073812480 as *const _
     }
-    #[doc = "common control register"]
-    pub mod ccr {
-        #[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::CCR {
-            #[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 = r" Value of the field"]
-        pub struct ADCPRER {
-            bits: u8,
-        }
-        impl ADCPRER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct VBATER {
-            bits: bool,
-        }
-        impl VBATER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSVREFER {
-            bits: bool,
-        }
-        impl TSVREFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ADCPREW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADCPREW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _VBATEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _VBATEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSVREFEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSVREFEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:17 - ADC prescaler"]
-            #[inline]
-            pub fn adcpre(&self) -> ADCPRER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADCPRER { bits }
-            }
-            #[doc = "Bit 22 - VBAT enable"]
-            #[inline]
-            pub fn vbate(&self) -> VBATER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                VBATER { bits }
-            }
-            #[doc = "Bit 23 - Temperature sensor and VREFINT enable"]
-            #[inline]
-            pub fn tsvrefe(&self) -> TSVREFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TSVREFER { bits }
-            }
-        }
-        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 16:17 - ADC prescaler"]
-            #[inline]
-            pub fn adcpre(&mut self) -> _ADCPREW {
-                _ADCPREW { w: self }
-            }
-            #[doc = "Bit 22 - VBAT enable"]
-            #[inline]
-            pub fn vbate(&mut self) -> _VBATEW {
-                _VBATEW { w: self }
-            }
-            #[doc = "Bit 23 - Temperature sensor and VREFINT enable"]
-            #[inline]
-            pub fn tsvrefe(&mut self) -> _TSVREFEW {
-                _TSVREFEW { w: self }
-            }
-        }
+}
+impl Deref for USART6 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*USART6::ptr() }
     }
 }
-#[doc = "Cryptographic processor"]
-pub struct CRC {
+#[doc = "USART3"]
+pub struct USART3 {
     _marker: PhantomData<*const ()>,
 }
-unsafe impl Send for CRC {}
-impl CRC {
+unsafe impl Send for USART3 {}
+impl USART3 {
     #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const crc::RegisterBlock {
-        0x4002_3000 as *const _
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073760256 as *const _
     }
 }
-impl Deref for CRC {
-    type Target = crc::RegisterBlock;
-    fn deref(&self) -> &crc::RegisterBlock {
-        unsafe { &*CRC::ptr() }
+impl Deref for USART3 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*USART3::ptr() }
     }
 }
-#[doc = "Cryptographic processor"]
-pub mod crc {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Data register"]
-        pub dr: DR,
-        #[doc = "0x04 - Independent Data register"]
-        pub idr: IDR,
-        #[doc = "0x08 - Control register"]
-        pub cr: CR,
+#[doc = "UART4"]
+pub struct UART4 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for UART4 {}
+impl UART4 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073761280 as *const _
     }
-    #[doc = "Data register"]
-    pub struct DR {
-        register: VolatileCell<u32>,
+}
+impl Deref for UART4 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*UART4::ptr() }
     }
-    #[doc = "Data register"]
-    pub mod dr {
-        #[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::DR {
-            #[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 = r" Value of the field"]
-        pub struct DRR {
-            bits: u32,
-        }
-        impl DRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Data Register"]
-            #[inline]
-            pub fn dr(&self) -> DRR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                DRR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xffff_ffff }
-            }
-            #[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 0:31 - Data Register"]
-            #[inline]
-            pub fn dr(&mut self) -> _DRW {
-                _DRW { w: self }
-            }
-        }
+}
+#[doc = "UART5"]
+pub struct UART5 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for UART5 {}
+impl UART5 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073762304 as *const _
     }
-    #[doc = "Independent Data register"]
-    pub struct IDR {
-        register: VolatileCell<u32>,
+}
+impl Deref for UART5 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*UART5::ptr() }
     }
-    #[doc = "Independent Data register"]
-    pub mod idr {
-        #[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::IDR {
-            #[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 = r" Value of the field"]
-        pub struct IDRR {
-            bits: u8,
-        }
-        impl IDRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IDRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IDRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - Independent Data register"]
-            #[inline]
-            pub fn idr(&self) -> IDRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IDRR { bits }
-            }
-        }
-        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 0:7 - Independent Data register"]
-            #[inline]
-            pub fn idr(&mut self) -> _IDRW {
-                _IDRW { w: self }
-            }
-        }
+}
+#[doc = "UART7"]
+pub struct UART7 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for UART7 {}
+impl UART7 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073772544 as *const _
     }
-    #[doc = "Control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
+}
+impl Deref for UART7 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*UART7::ptr() }
     }
-    #[doc = "Control register"]
-    pub mod cr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::CR {
-            #[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" Proxy"]
-        pub struct _CRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRW<'a> {
-            #[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
-            }
-        }
-        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 - Control regidter"]
-            #[inline]
-            pub fn cr(&mut self) -> _CRW {
-                _CRW { w: self }
-            }
-        }
+}
+#[doc = "UART8"]
+pub struct UART8 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for UART8 {}
+impl UART8 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073773568 as *const _
     }
 }
-#[doc = "Debug support"]
-pub struct DBG {
+impl Deref for UART8 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*UART8::ptr() }
+    }
+}
+#[doc = "UART9"]
+pub struct UART9 {
     _marker: PhantomData<*const ()>,
 }
-unsafe impl Send for DBG {}
-impl DBG {
+unsafe impl Send for UART9 {}
+impl UART9 {
     #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const dbg::RegisterBlock {
-        0xe004_2000 as *const _
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073813504 as *const _
     }
 }
-impl Deref for DBG {
-    type Target = dbg::RegisterBlock;
-    fn deref(&self) -> &dbg::RegisterBlock {
-        unsafe { &*DBG::ptr() }
+impl Deref for UART9 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*UART9::ptr() }
     }
 }
-#[doc = "Debug support"]
-pub mod dbg {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - IDCODE"]
-        pub dbgmcu_idcode: DBGMCU_IDCODE,
-        #[doc = "0x04 - Control Register"]
-        pub dbgmcu_cr: DBGMCU_CR,
-        #[doc = "0x08 - Debug MCU APB1 Freeze registe"]
-        pub dbgmcu_apb1_fz: DBGMCU_APB1_FZ,
-        #[doc = "0x0c - Debug MCU APB2 Freeze registe"]
-        pub dbgmcu_apb2_fz: DBGMCU_APB2_FZ,
+#[doc = "UART10"]
+pub struct UART10 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for UART10 {}
+impl UART10 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const usart1::RegisterBlock {
+        1073814528 as *const _
     }
-    #[doc = "IDCODE"]
-    pub struct DBGMCU_IDCODE {
-        register: VolatileCell<u32>,
+}
+impl Deref for UART10 {
+    type Target = usart1::RegisterBlock;
+    fn deref(&self) -> &usart1::RegisterBlock {
+        unsafe { &*UART10::ptr() }
     }
-    #[doc = "IDCODE"]
-    pub mod dbgmcu_idcode {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DBGMCU_IDCODE {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DEV_IDR {
-            bits: u16,
-        }
-        impl DEV_IDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct REV_IDR {
-            bits: u16,
-        }
-        impl REV_IDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:11 - DEV_ID"]
-            #[inline]
-            pub fn dev_id(&self) -> DEV_IDR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DEV_IDR { bits }
-            }
-            #[doc = "Bits 16:31 - REV_ID"]
-            #[inline]
-            pub fn rev_id(&self) -> REV_IDR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                REV_IDR { bits }
-            }
-        }
+}
+#[doc = "Window watchdog"]
+pub struct WWDG {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for WWDG {}
+impl WWDG {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const wwdg::RegisterBlock {
+        1073753088 as *const _
     }
-    #[doc = "Control Register"]
-    pub struct DBGMCU_CR {
-        register: VolatileCell<u32>,
+}
+impl Deref for WWDG {
+    type Target = wwdg::RegisterBlock;
+    fn deref(&self) -> &wwdg::RegisterBlock {
+        unsafe { &*WWDG::ptr() }
     }
-    #[doc = "Control Register"]
-    pub mod dbgmcu_cr {
-        #[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::DBGMCU_CR {
-            #[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 = r" Value of the field"]
-        pub struct DBG_SLEEPR {
-            bits: bool,
-        }
-        impl DBG_SLEEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_STOPR {
-            bits: bool,
-        }
-        impl DBG_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_STANDBYR {
-            bits: bool,
-        }
-        impl DBG_STANDBYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TRACE_IOENR {
-            bits: bool,
-        }
-        impl TRACE_IOENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TRACE_MODER {
-            bits: u8,
-        }
-        impl TRACE_MODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBG_SLEEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_SLEEPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_STANDBYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_STANDBYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TRACE_IOENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRACE_IOENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TRACE_MODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRACE_MODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                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 - DBG_SLEEP"]
-            #[inline]
-            pub fn dbg_sleep(&self) -> DBG_SLEEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_SLEEPR { bits }
-            }
-            #[doc = "Bit 1 - DBG_STOP"]
-            #[inline]
-            pub fn dbg_stop(&self) -> DBG_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_STOPR { bits }
-            }
-            #[doc = "Bit 2 - DBG_STANDBY"]
-            #[inline]
-            pub fn dbg_standby(&self) -> DBG_STANDBYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_STANDBYR { bits }
-            }
-            #[doc = "Bit 5 - TRACE_IOEN"]
-            #[inline]
-            pub fn trace_ioen(&self) -> TRACE_IOENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TRACE_IOENR { bits }
-            }
-            #[doc = "Bits 6:7 - TRACE_MODE"]
-            #[inline]
-            pub fn trace_mode(&self) -> TRACE_MODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TRACE_MODER { bits }
-            }
-        }
-        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 - DBG_SLEEP"]
-            #[inline]
-            pub fn dbg_sleep(&mut self) -> _DBG_SLEEPW {
-                _DBG_SLEEPW { w: self }
-            }
-            #[doc = "Bit 1 - DBG_STOP"]
-            #[inline]
-            pub fn dbg_stop(&mut self) -> _DBG_STOPW {
-                _DBG_STOPW { w: self }
-            }
-            #[doc = "Bit 2 - DBG_STANDBY"]
-            #[inline]
-            pub fn dbg_standby(&mut self) -> _DBG_STANDBYW {
-                _DBG_STANDBYW { w: self }
-            }
-            #[doc = "Bit 5 - TRACE_IOEN"]
-            #[inline]
-            pub fn trace_ioen(&mut self) -> _TRACE_IOENW {
-                _TRACE_IOENW { w: self }
-            }
-            #[doc = "Bits 6:7 - TRACE_MODE"]
-            #[inline]
-            pub fn trace_mode(&mut self) -> _TRACE_MODEW {
-                _TRACE_MODEW { w: self }
-            }
-        }
+}
+#[doc = "Window watchdog"]
+pub mod wwdg;
+#[doc = "DMA controller"]
+pub struct DMA2 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DMA2 {}
+impl DMA2 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const dma2::RegisterBlock {
+        1073898496 as *const _
     }
-    #[doc = "Debug MCU APB1 Freeze registe"]
-    pub struct DBGMCU_APB1_FZ {
-        register: VolatileCell<u32>,
+}
+impl Deref for DMA2 {
+    type Target = dma2::RegisterBlock;
+    fn deref(&self) -> &dma2::RegisterBlock {
+        unsafe { &*DMA2::ptr() }
     }
-    #[doc = "Debug MCU APB1 Freeze registe"]
-    pub mod dbgmcu_apb1_fz {
-        #[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::DBGMCU_APB1_FZ {
-            #[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 = r" Value of the field"]
-        pub struct DBG_TIM2_STOPR {
-            bits: bool,
-        }
-        impl DBG_TIM2_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_TIM3_STOPR {
-            bits: bool,
-        }
-        impl DBG_TIM3_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_TIM4_STOPR {
-            bits: bool,
-        }
-        impl DBG_TIM4_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_TIM5_STOPR {
-            bits: bool,
-        }
-        impl DBG_TIM5_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_RTC_STOPR {
-            bits: bool,
-        }
-        impl DBG_RTC_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_WWDG_STOPR {
-            bits: bool,
-        }
-        impl DBG_WWDG_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_IWDEG_STOPR {
-            bits: bool,
-        }
-        impl DBG_IWDEG_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_I2C1_SMBUS_TIMEOUTR {
-            bits: bool,
-        }
-        impl DBG_I2C1_SMBUS_TIMEOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_I2C2_SMBUS_TIMEOUTR {
-            bits: bool,
-        }
-        impl DBG_I2C2_SMBUS_TIMEOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_I2C3SMBUS_TIMEOUTR {
-            bits: bool,
-        }
-        impl DBG_I2C3SMBUS_TIMEOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _DBG_TIM2_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_TIM2_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_TIM3_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_TIM3_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_TIM4_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_TIM4_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_TIM5_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_TIM5_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_RTC_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_RTC_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_WWDG_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_WWDG_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_IWDEG_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_IWDEG_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_I2C1_SMBUS_TIMEOUTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_I2C1_SMBUS_TIMEOUTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_I2C2_SMBUS_TIMEOUTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_I2C2_SMBUS_TIMEOUTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_I2C3SMBUS_TIMEOUTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_I2C3SMBUS_TIMEOUTW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - DBG_TIM2_STOP"]
-            #[inline]
-            pub fn dbg_tim2_stop(&self) -> DBG_TIM2_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_TIM2_STOPR { bits }
-            }
-            #[doc = "Bit 1 - DBG_TIM3 _STOP"]
-            #[inline]
-            pub fn dbg_tim3_stop(&self) -> DBG_TIM3_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_TIM3_STOPR { bits }
-            }
-            #[doc = "Bit 2 - DBG_TIM4_STOP"]
-            #[inline]
-            pub fn dbg_tim4_stop(&self) -> DBG_TIM4_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_TIM4_STOPR { bits }
-            }
-            #[doc = "Bit 3 - DBG_TIM5_STOP"]
-            #[inline]
-            pub fn dbg_tim5_stop(&self) -> DBG_TIM5_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_TIM5_STOPR { bits }
-            }
-            #[doc = "Bit 10 - RTC stopped when Core is halted"]
-            #[inline]
-            pub fn dbg_rtc_stop(&self) -> DBG_RTC_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_RTC_STOPR { bits }
-            }
-            #[doc = "Bit 11 - DBG_WWDG_STOP"]
-            #[inline]
-            pub fn dbg_wwdg_stop(&self) -> DBG_WWDG_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_WWDG_STOPR { bits }
-            }
-            #[doc = "Bit 12 - DBG_IWDEG_STOP"]
-            #[inline]
-            pub fn dbg_iwdeg_stop(&self) -> DBG_IWDEG_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_IWDEG_STOPR { bits }
-            }
-            #[doc = "Bit 21 - DBG_J2C1_SMBUS_TIMEOUT"]
-            #[inline]
-            pub fn dbg_i2c1_smbus_timeout(&self) -> DBG_I2C1_SMBUS_TIMEOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_I2C1_SMBUS_TIMEOUTR { bits }
-            }
-            #[doc = "Bit 22 - DBG_J2C2_SMBUS_TIMEOUT"]
-            #[inline]
-            pub fn dbg_i2c2_smbus_timeout(&self) -> DBG_I2C2_SMBUS_TIMEOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_I2C2_SMBUS_TIMEOUTR { bits }
-            }
-            #[doc = "Bit 23 - DBG_J2C3SMBUS_TIMEOUT"]
-            #[inline]
-            pub fn dbg_i2c3smbus_timeout(&self) -> DBG_I2C3SMBUS_TIMEOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_I2C3SMBUS_TIMEOUTR { bits }
-            }
-        }
-        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 - DBG_TIM2_STOP"]
-            #[inline]
-            pub fn dbg_tim2_stop(&mut self) -> _DBG_TIM2_STOPW {
-                _DBG_TIM2_STOPW { w: self }
-            }
-            #[doc = "Bit 1 - DBG_TIM3 _STOP"]
-            #[inline]
-            pub fn dbg_tim3_stop(&mut self) -> _DBG_TIM3_STOPW {
-                _DBG_TIM3_STOPW { w: self }
-            }
-            #[doc = "Bit 2 - DBG_TIM4_STOP"]
-            #[inline]
-            pub fn dbg_tim4_stop(&mut self) -> _DBG_TIM4_STOPW {
-                _DBG_TIM4_STOPW { w: self }
-            }
-            #[doc = "Bit 3 - DBG_TIM5_STOP"]
-            #[inline]
-            pub fn dbg_tim5_stop(&mut self) -> _DBG_TIM5_STOPW {
-                _DBG_TIM5_STOPW { w: self }
-            }
-            #[doc = "Bit 10 - RTC stopped when Core is halted"]
-            #[inline]
-            pub fn dbg_rtc_stop(&mut self) -> _DBG_RTC_STOPW {
-                _DBG_RTC_STOPW { w: self }
-            }
-            #[doc = "Bit 11 - DBG_WWDG_STOP"]
-            #[inline]
-            pub fn dbg_wwdg_stop(&mut self) -> _DBG_WWDG_STOPW {
-                _DBG_WWDG_STOPW { w: self }
-            }
-            #[doc = "Bit 12 - DBG_IWDEG_STOP"]
-            #[inline]
-            pub fn dbg_iwdeg_stop(&mut self) -> _DBG_IWDEG_STOPW {
-                _DBG_IWDEG_STOPW { w: self }
-            }
-            #[doc = "Bit 21 - DBG_J2C1_SMBUS_TIMEOUT"]
-            #[inline]
-            pub fn dbg_i2c1_smbus_timeout(&mut self) -> _DBG_I2C1_SMBUS_TIMEOUTW {
-                _DBG_I2C1_SMBUS_TIMEOUTW { w: self }
-            }
-            #[doc = "Bit 22 - DBG_J2C2_SMBUS_TIMEOUT"]
-            #[inline]
-            pub fn dbg_i2c2_smbus_timeout(&mut self) -> _DBG_I2C2_SMBUS_TIMEOUTW {
-                _DBG_I2C2_SMBUS_TIMEOUTW { w: self }
-            }
-            #[doc = "Bit 23 - DBG_J2C3SMBUS_TIMEOUT"]
-            #[inline]
-            pub fn dbg_i2c3smbus_timeout(&mut self) -> _DBG_I2C3SMBUS_TIMEOUTW {
-                _DBG_I2C3SMBUS_TIMEOUTW { w: self }
-            }
-        }
+}
+#[doc = "DMA controller"]
+pub mod dma2;
+#[doc = "DMA1"]
+pub struct DMA1 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DMA1 {}
+impl DMA1 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const dma2::RegisterBlock {
+        1073897472 as *const _
     }
-    #[doc = "Debug MCU APB2 Freeze registe"]
-    pub struct DBGMCU_APB2_FZ {
-        register: VolatileCell<u32>,
+}
+impl Deref for DMA1 {
+    type Target = dma2::RegisterBlock;
+    fn deref(&self) -> &dma2::RegisterBlock {
+        unsafe { &*DMA1::ptr() }
     }
-    #[doc = "Debug MCU APB2 Freeze registe"]
-    pub mod dbgmcu_apb2_fz {
-        #[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::DBGMCU_APB2_FZ {
-            #[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 = r" Value of the field"]
-        pub struct DBG_TIM1_STOPR {
-            bits: bool,
-        }
-        impl DBG_TIM1_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_TIM9_STOPR {
-            bits: bool,
-        }
-        impl DBG_TIM9_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_TIM10_STOPR {
-            bits: bool,
-        }
-        impl DBG_TIM10_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBG_TIM11_STOPR {
-            bits: bool,
-        }
-        impl DBG_TIM11_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _DBG_TIM1_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_TIM1_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_TIM9_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_TIM9_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_TIM10_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_TIM10_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBG_TIM11_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBG_TIM11_STOPW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - TIM1 counter stopped when core is halted"]
-            #[inline]
-            pub fn dbg_tim1_stop(&self) -> DBG_TIM1_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_TIM1_STOPR { bits }
-            }
-            #[doc = "Bit 16 - TIM9 counter stopped when core is halted"]
-            #[inline]
-            pub fn dbg_tim9_stop(&self) -> DBG_TIM9_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_TIM9_STOPR { bits }
-            }
-            #[doc = "Bit 17 - TIM10 counter stopped when core is halted"]
-            #[inline]
-            pub fn dbg_tim10_stop(&self) -> DBG_TIM10_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_TIM10_STOPR { bits }
-            }
-            #[doc = "Bit 18 - TIM11 counter stopped when core is halted"]
-            #[inline]
-            pub fn dbg_tim11_stop(&self) -> DBG_TIM11_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBG_TIM11_STOPR { bits }
-            }
-        }
-        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 - TIM1 counter stopped when core is halted"]
-            #[inline]
-            pub fn dbg_tim1_stop(&mut self) -> _DBG_TIM1_STOPW {
-                _DBG_TIM1_STOPW { w: self }
-            }
-            #[doc = "Bit 16 - TIM9 counter stopped when core is halted"]
-            #[inline]
-            pub fn dbg_tim9_stop(&mut self) -> _DBG_TIM9_STOPW {
-                _DBG_TIM9_STOPW { w: self }
-            }
-            #[doc = "Bit 17 - TIM10 counter stopped when core is halted"]
-            #[inline]
-            pub fn dbg_tim10_stop(&mut self) -> _DBG_TIM10_STOPW {
-                _DBG_TIM10_STOPW { w: self }
-            }
-            #[doc = "Bit 18 - TIM11 counter stopped when core is halted"]
-            #[inline]
-            pub fn dbg_tim11_stop(&mut self) -> _DBG_TIM11_STOPW {
-                _DBG_TIM11_STOPW { w: self }
-            }
-        }
+}
+#[doc = "General-purpose I/Os"]
+pub struct GPIOH {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for GPIOH {}
+impl GPIOH {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const gpioh::RegisterBlock {
+        1073880064 as *const _
     }
 }
-#[doc = "External interrupt/event controller"]
-pub struct EXTI {
+impl Deref for GPIOH {
+    type Target = gpioh::RegisterBlock;
+    fn deref(&self) -> &gpioh::RegisterBlock {
+        unsafe { &*GPIOH::ptr() }
+    }
+}
+#[doc = "General-purpose I/Os"]
+pub mod gpioh;
+#[doc = "GPIOE"]
+pub struct GPIOE {
     _marker: PhantomData<*const ()>,
 }
-unsafe impl Send for EXTI {}
-impl EXTI {
+unsafe impl Send for GPIOE {}
+impl GPIOE {
     #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const exti::RegisterBlock {
-        0x4001_3c00 as *const _
+    pub fn ptr() -> *const gpioh::RegisterBlock {
+        1073876992 as *const _
     }
 }
-impl Deref for EXTI {
-    type Target = exti::RegisterBlock;
-    fn deref(&self) -> &exti::RegisterBlock {
-        unsafe { &*EXTI::ptr() }
+impl Deref for GPIOE {
+    type Target = gpioh::RegisterBlock;
+    fn deref(&self) -> &gpioh::RegisterBlock {
+        unsafe { &*GPIOE::ptr() }
     }
 }
-#[doc = "External interrupt/event controller"]
-pub mod exti {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Interrupt mask register (EXTI_IMR)"]
-        pub imr: IMR,
-        #[doc = "0x04 - Event mask register (EXTI_EMR)"]
-        pub emr: EMR,
-        #[doc = "0x08 - Rising Trigger selection register (EXTI_RTSR)"]
-        pub rtsr: RTSR,
-        #[doc = "0x0c - Falling Trigger selection register (EXTI_FTSR)"]
-        pub ftsr: FTSR,
-        #[doc = "0x10 - Software interrupt event register (EXTI_SWIER)"]
-        pub swier: SWIER,
-        #[doc = "0x14 - Pending register (EXTI_PR)"]
-        pub pr: PR,
+#[doc = "GPIOD"]
+pub struct GPIOD {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for GPIOD {}
+impl GPIOD {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const gpioh::RegisterBlock {
+        1073875968 as *const _
     }
-    #[doc = "Interrupt mask register (EXTI_IMR)"]
-    pub struct IMR {
-        register: VolatileCell<u32>,
+}
+impl Deref for GPIOD {
+    type Target = gpioh::RegisterBlock;
+    fn deref(&self) -> &gpioh::RegisterBlock {
+        unsafe { &*GPIOD::ptr() }
     }
-    #[doc = "Interrupt mask register (EXTI_IMR)"]
-    pub mod imr {
-        #[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::IMR {
-            #[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 = r" Value of the field"]
-        pub struct MR0R {
-            bits: bool,
-        }
-        impl MR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR1R {
-            bits: bool,
-        }
-        impl MR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR2R {
-            bits: bool,
-        }
-        impl MR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR3R {
-            bits: bool,
-        }
-        impl MR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR4R {
-            bits: bool,
-        }
-        impl MR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR5R {
-            bits: bool,
-        }
-        impl MR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR6R {
-            bits: bool,
-        }
-        impl MR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR7R {
-            bits: bool,
-        }
-        impl MR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR8R {
-            bits: bool,
-        }
-        impl MR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR9R {
-            bits: bool,
-        }
-        impl MR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR10R {
-            bits: bool,
-        }
-        impl MR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR11R {
-            bits: bool,
-        }
-        impl MR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR12R {
-            bits: bool,
-        }
-        impl MR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR13R {
-            bits: bool,
-        }
-        impl MR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR14R {
-            bits: bool,
-        }
-        impl MR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR15R {
-            bits: bool,
-        }
-        impl MR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR16R {
-            bits: bool,
-        }
-        impl MR16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR17R {
-            bits: bool,
-        }
-        impl MR17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR18R {
-            bits: bool,
-        }
-        impl MR18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR19R {
-            bits: bool,
-        }
-        impl MR19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR20R {
-            bits: bool,
-        }
-        impl MR20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR21R {
-            bits: bool,
-        }
-        impl MR21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR22R {
-            bits: bool,
-        }
-        impl MR22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR22W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Interrupt Mask on line 0"]
-            #[inline]
-            pub fn mr0(&self) -> MR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR0R { bits }
-            }
-            #[doc = "Bit 1 - Interrupt Mask on line 1"]
-            #[inline]
-            pub fn mr1(&self) -> MR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR1R { bits }
-            }
-            #[doc = "Bit 2 - Interrupt Mask on line 2"]
-            #[inline]
-            pub fn mr2(&self) -> MR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR2R { bits }
-            }
-            #[doc = "Bit 3 - Interrupt Mask on line 3"]
-            #[inline]
-            pub fn mr3(&self) -> MR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR3R { bits }
-            }
-            #[doc = "Bit 4 - Interrupt Mask on line 4"]
-            #[inline]
-            pub fn mr4(&self) -> MR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR4R { bits }
-            }
-            #[doc = "Bit 5 - Interrupt Mask on line 5"]
-            #[inline]
-            pub fn mr5(&self) -> MR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR5R { bits }
-            }
-            #[doc = "Bit 6 - Interrupt Mask on line 6"]
-            #[inline]
-            pub fn mr6(&self) -> MR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR6R { bits }
-            }
-            #[doc = "Bit 7 - Interrupt Mask on line 7"]
-            #[inline]
-            pub fn mr7(&self) -> MR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR7R { bits }
-            }
-            #[doc = "Bit 8 - Interrupt Mask on line 8"]
-            #[inline]
-            pub fn mr8(&self) -> MR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR8R { bits }
-            }
-            #[doc = "Bit 9 - Interrupt Mask on line 9"]
-            #[inline]
-            pub fn mr9(&self) -> MR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR9R { bits }
-            }
-            #[doc = "Bit 10 - Interrupt Mask on line 10"]
-            #[inline]
-            pub fn mr10(&self) -> MR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR10R { bits }
-            }
-            #[doc = "Bit 11 - Interrupt Mask on line 11"]
-            #[inline]
-            pub fn mr11(&self) -> MR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR11R { bits }
-            }
-            #[doc = "Bit 12 - Interrupt Mask on line 12"]
-            #[inline]
-            pub fn mr12(&self) -> MR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR12R { bits }
-            }
-            #[doc = "Bit 13 - Interrupt Mask on line 13"]
-            #[inline]
-            pub fn mr13(&self) -> MR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR13R { bits }
-            }
-            #[doc = "Bit 14 - Interrupt Mask on line 14"]
-            #[inline]
-            pub fn mr14(&self) -> MR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR14R { bits }
-            }
-            #[doc = "Bit 15 - Interrupt Mask on line 15"]
-            #[inline]
-            pub fn mr15(&self) -> MR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR15R { bits }
-            }
-            #[doc = "Bit 16 - Interrupt Mask on line 16"]
-            #[inline]
-            pub fn mr16(&self) -> MR16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR16R { bits }
-            }
-            #[doc = "Bit 17 - Interrupt Mask on line 17"]
-            #[inline]
-            pub fn mr17(&self) -> MR17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR17R { bits }
-            }
-            #[doc = "Bit 18 - Interrupt Mask on line 18"]
-            #[inline]
-            pub fn mr18(&self) -> MR18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR18R { bits }
-            }
-            #[doc = "Bit 19 - Interrupt Mask on line 19"]
-            #[inline]
-            pub fn mr19(&self) -> MR19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR19R { bits }
-            }
-            #[doc = "Bit 20 - Interrupt Mask on line 20"]
-            #[inline]
-            pub fn mr20(&self) -> MR20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR20R { bits }
-            }
-            #[doc = "Bit 21 - Interrupt Mask on line 21"]
-            #[inline]
-            pub fn mr21(&self) -> MR21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR21R { bits }
-            }
-            #[doc = "Bit 22 - Interrupt Mask on line 22"]
-            #[inline]
-            pub fn mr22(&self) -> MR22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR22R { bits }
-            }
-        }
-        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 Mask on line 0"]
-            #[inline]
-            pub fn mr0(&mut self) -> _MR0W {
-                _MR0W { w: self }
-            }
-            #[doc = "Bit 1 - Interrupt Mask on line 1"]
-            #[inline]
-            pub fn mr1(&mut self) -> _MR1W {
-                _MR1W { w: self }
-            }
-            #[doc = "Bit 2 - Interrupt Mask on line 2"]
-            #[inline]
-            pub fn mr2(&mut self) -> _MR2W {
-                _MR2W { w: self }
-            }
-            #[doc = "Bit 3 - Interrupt Mask on line 3"]
-            #[inline]
-            pub fn mr3(&mut self) -> _MR3W {
-                _MR3W { w: self }
-            }
-            #[doc = "Bit 4 - Interrupt Mask on line 4"]
-            #[inline]
-            pub fn mr4(&mut self) -> _MR4W {
-                _MR4W { w: self }
-            }
-            #[doc = "Bit 5 - Interrupt Mask on line 5"]
-            #[inline]
-            pub fn mr5(&mut self) -> _MR5W {
-                _MR5W { w: self }
-            }
-            #[doc = "Bit 6 - Interrupt Mask on line 6"]
-            #[inline]
-            pub fn mr6(&mut self) -> _MR6W {
-                _MR6W { w: self }
-            }
-            #[doc = "Bit 7 - Interrupt Mask on line 7"]
-            #[inline]
-            pub fn mr7(&mut self) -> _MR7W {
-                _MR7W { w: self }
-            }
-            #[doc = "Bit 8 - Interrupt Mask on line 8"]
-            #[inline]
-            pub fn mr8(&mut self) -> _MR8W {
-                _MR8W { w: self }
-            }
-            #[doc = "Bit 9 - Interrupt Mask on line 9"]
-            #[inline]
-            pub fn mr9(&mut self) -> _MR9W {
-                _MR9W { w: self }
-            }
-            #[doc = "Bit 10 - Interrupt Mask on line 10"]
-            #[inline]
-            pub fn mr10(&mut self) -> _MR10W {
-                _MR10W { w: self }
-            }
-            #[doc = "Bit 11 - Interrupt Mask on line 11"]
-            #[inline]
-            pub fn mr11(&mut self) -> _MR11W {
-                _MR11W { w: self }
-            }
-            #[doc = "Bit 12 - Interrupt Mask on line 12"]
-            #[inline]
-            pub fn mr12(&mut self) -> _MR12W {
-                _MR12W { w: self }
-            }
-            #[doc = "Bit 13 - Interrupt Mask on line 13"]
-            #[inline]
-            pub fn mr13(&mut self) -> _MR13W {
-                _MR13W { w: self }
-            }
-            #[doc = "Bit 14 - Interrupt Mask on line 14"]
-            #[inline]
-            pub fn mr14(&mut self) -> _MR14W {
-                _MR14W { w: self }
-            }
-            #[doc = "Bit 15 - Interrupt Mask on line 15"]
-            #[inline]
-            pub fn mr15(&mut self) -> _MR15W {
-                _MR15W { w: self }
-            }
-            #[doc = "Bit 16 - Interrupt Mask on line 16"]
-            #[inline]
-            pub fn mr16(&mut self) -> _MR16W {
-                _MR16W { w: self }
-            }
-            #[doc = "Bit 17 - Interrupt Mask on line 17"]
-            #[inline]
-            pub fn mr17(&mut self) -> _MR17W {
-                _MR17W { w: self }
-            }
-            #[doc = "Bit 18 - Interrupt Mask on line 18"]
-            #[inline]
-            pub fn mr18(&mut self) -> _MR18W {
-                _MR18W { w: self }
-            }
-            #[doc = "Bit 19 - Interrupt Mask on line 19"]
-            #[inline]
-            pub fn mr19(&mut self) -> _MR19W {
-                _MR19W { w: self }
-            }
-            #[doc = "Bit 20 - Interrupt Mask on line 20"]
-            #[inline]
-            pub fn mr20(&mut self) -> _MR20W {
-                _MR20W { w: self }
-            }
-            #[doc = "Bit 21 - Interrupt Mask on line 21"]
-            #[inline]
-            pub fn mr21(&mut self) -> _MR21W {
-                _MR21W { w: self }
-            }
-            #[doc = "Bit 22 - Interrupt Mask on line 22"]
-            #[inline]
-            pub fn mr22(&mut self) -> _MR22W {
-                _MR22W { w: self }
-            }
-        }
-    }
-    #[doc = "Event mask register (EXTI_EMR)"]
-    pub struct EMR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Event mask register (EXTI_EMR)"]
-    pub mod emr {
-        #[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::EMR {
-            #[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 = r" Value of the field"]
-        pub struct MR0R {
-            bits: bool,
-        }
-        impl MR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR1R {
-            bits: bool,
-        }
-        impl MR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR2R {
-            bits: bool,
-        }
-        impl MR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR3R {
-            bits: bool,
-        }
-        impl MR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR4R {
-            bits: bool,
-        }
-        impl MR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR5R {
-            bits: bool,
-        }
-        impl MR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR6R {
-            bits: bool,
-        }
-        impl MR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR7R {
-            bits: bool,
-        }
-        impl MR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR8R {
-            bits: bool,
-        }
-        impl MR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR9R {
-            bits: bool,
-        }
-        impl MR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR10R {
-            bits: bool,
-        }
-        impl MR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR11R {
-            bits: bool,
-        }
-        impl MR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR12R {
-            bits: bool,
-        }
-        impl MR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR13R {
-            bits: bool,
-        }
-        impl MR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR14R {
-            bits: bool,
-        }
-        impl MR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR15R {
-            bits: bool,
-        }
-        impl MR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR16R {
-            bits: bool,
-        }
-        impl MR16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR17R {
-            bits: bool,
-        }
-        impl MR17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR18R {
-            bits: bool,
-        }
-        impl MR18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR19R {
-            bits: bool,
-        }
-        impl MR19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR20R {
-            bits: bool,
-        }
-        impl MR20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR21R {
-            bits: bool,
-        }
-        impl MR21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR22R {
-            bits: bool,
-        }
-        impl MR22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MR22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MR22W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Event Mask on line 0"]
-            #[inline]
-            pub fn mr0(&self) -> MR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR0R { bits }
-            }
-            #[doc = "Bit 1 - Event Mask on line 1"]
-            #[inline]
-            pub fn mr1(&self) -> MR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR1R { bits }
-            }
-            #[doc = "Bit 2 - Event Mask on line 2"]
-            #[inline]
-            pub fn mr2(&self) -> MR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR2R { bits }
-            }
-            #[doc = "Bit 3 - Event Mask on line 3"]
-            #[inline]
-            pub fn mr3(&self) -> MR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR3R { bits }
-            }
-            #[doc = "Bit 4 - Event Mask on line 4"]
-            #[inline]
-            pub fn mr4(&self) -> MR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR4R { bits }
-            }
-            #[doc = "Bit 5 - Event Mask on line 5"]
-            #[inline]
-            pub fn mr5(&self) -> MR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR5R { bits }
-            }
-            #[doc = "Bit 6 - Event Mask on line 6"]
-            #[inline]
-            pub fn mr6(&self) -> MR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR6R { bits }
-            }
-            #[doc = "Bit 7 - Event Mask on line 7"]
-            #[inline]
-            pub fn mr7(&self) -> MR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR7R { bits }
-            }
-            #[doc = "Bit 8 - Event Mask on line 8"]
-            #[inline]
-            pub fn mr8(&self) -> MR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR8R { bits }
-            }
-            #[doc = "Bit 9 - Event Mask on line 9"]
-            #[inline]
-            pub fn mr9(&self) -> MR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR9R { bits }
-            }
-            #[doc = "Bit 10 - Event Mask on line 10"]
-            #[inline]
-            pub fn mr10(&self) -> MR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR10R { bits }
-            }
-            #[doc = "Bit 11 - Event Mask on line 11"]
-            #[inline]
-            pub fn mr11(&self) -> MR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR11R { bits }
-            }
-            #[doc = "Bit 12 - Event Mask on line 12"]
-            #[inline]
-            pub fn mr12(&self) -> MR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR12R { bits }
-            }
-            #[doc = "Bit 13 - Event Mask on line 13"]
-            #[inline]
-            pub fn mr13(&self) -> MR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR13R { bits }
-            }
-            #[doc = "Bit 14 - Event Mask on line 14"]
-            #[inline]
-            pub fn mr14(&self) -> MR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR14R { bits }
-            }
-            #[doc = "Bit 15 - Event Mask on line 15"]
-            #[inline]
-            pub fn mr15(&self) -> MR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR15R { bits }
-            }
-            #[doc = "Bit 16 - Event Mask on line 16"]
-            #[inline]
-            pub fn mr16(&self) -> MR16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR16R { bits }
-            }
-            #[doc = "Bit 17 - Event Mask on line 17"]
-            #[inline]
-            pub fn mr17(&self) -> MR17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR17R { bits }
-            }
-            #[doc = "Bit 18 - Event Mask on line 18"]
-            #[inline]
-            pub fn mr18(&self) -> MR18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR18R { bits }
-            }
-            #[doc = "Bit 19 - Event Mask on line 19"]
-            #[inline]
-            pub fn mr19(&self) -> MR19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR19R { bits }
-            }
-            #[doc = "Bit 20 - Event Mask on line 20"]
-            #[inline]
-            pub fn mr20(&self) -> MR20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR20R { bits }
-            }
-            #[doc = "Bit 21 - Event Mask on line 21"]
-            #[inline]
-            pub fn mr21(&self) -> MR21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR21R { bits }
-            }
-            #[doc = "Bit 22 - Event Mask on line 22"]
-            #[inline]
-            pub fn mr22(&self) -> MR22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR22R { bits }
-            }
-        }
-        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 - Event Mask on line 0"]
-            #[inline]
-            pub fn mr0(&mut self) -> _MR0W {
-                _MR0W { w: self }
-            }
-            #[doc = "Bit 1 - Event Mask on line 1"]
-            #[inline]
-            pub fn mr1(&mut self) -> _MR1W {
-                _MR1W { w: self }
-            }
-            #[doc = "Bit 2 - Event Mask on line 2"]
-            #[inline]
-            pub fn mr2(&mut self) -> _MR2W {
-                _MR2W { w: self }
-            }
-            #[doc = "Bit 3 - Event Mask on line 3"]
-            #[inline]
-            pub fn mr3(&mut self) -> _MR3W {
-                _MR3W { w: self }
-            }
-            #[doc = "Bit 4 - Event Mask on line 4"]
-            #[inline]
-            pub fn mr4(&mut self) -> _MR4W {
-                _MR4W { w: self }
-            }
-            #[doc = "Bit 5 - Event Mask on line 5"]
-            #[inline]
-            pub fn mr5(&mut self) -> _MR5W {
-                _MR5W { w: self }
-            }
-            #[doc = "Bit 6 - Event Mask on line 6"]
-            #[inline]
-            pub fn mr6(&mut self) -> _MR6W {
-                _MR6W { w: self }
-            }
-            #[doc = "Bit 7 - Event Mask on line 7"]
-            #[inline]
-            pub fn mr7(&mut self) -> _MR7W {
-                _MR7W { w: self }
-            }
-            #[doc = "Bit 8 - Event Mask on line 8"]
-            #[inline]
-            pub fn mr8(&mut self) -> _MR8W {
-                _MR8W { w: self }
-            }
-            #[doc = "Bit 9 - Event Mask on line 9"]
-            #[inline]
-            pub fn mr9(&mut self) -> _MR9W {
-                _MR9W { w: self }
-            }
-            #[doc = "Bit 10 - Event Mask on line 10"]
-            #[inline]
-            pub fn mr10(&mut self) -> _MR10W {
-                _MR10W { w: self }
-            }
-            #[doc = "Bit 11 - Event Mask on line 11"]
-            #[inline]
-            pub fn mr11(&mut self) -> _MR11W {
-                _MR11W { w: self }
-            }
-            #[doc = "Bit 12 - Event Mask on line 12"]
-            #[inline]
-            pub fn mr12(&mut self) -> _MR12W {
-                _MR12W { w: self }
-            }
-            #[doc = "Bit 13 - Event Mask on line 13"]
-            #[inline]
-            pub fn mr13(&mut self) -> _MR13W {
-                _MR13W { w: self }
-            }
-            #[doc = "Bit 14 - Event Mask on line 14"]
-            #[inline]
-            pub fn mr14(&mut self) -> _MR14W {
-                _MR14W { w: self }
-            }
-            #[doc = "Bit 15 - Event Mask on line 15"]
-            #[inline]
-            pub fn mr15(&mut self) -> _MR15W {
-                _MR15W { w: self }
-            }
-            #[doc = "Bit 16 - Event Mask on line 16"]
-            #[inline]
-            pub fn mr16(&mut self) -> _MR16W {
-                _MR16W { w: self }
-            }
-            #[doc = "Bit 17 - Event Mask on line 17"]
-            #[inline]
-            pub fn mr17(&mut self) -> _MR17W {
-                _MR17W { w: self }
-            }
-            #[doc = "Bit 18 - Event Mask on line 18"]
-            #[inline]
-            pub fn mr18(&mut self) -> _MR18W {
-                _MR18W { w: self }
-            }
-            #[doc = "Bit 19 - Event Mask on line 19"]
-            #[inline]
-            pub fn mr19(&mut self) -> _MR19W {
-                _MR19W { w: self }
-            }
-            #[doc = "Bit 20 - Event Mask on line 20"]
-            #[inline]
-            pub fn mr20(&mut self) -> _MR20W {
-                _MR20W { w: self }
-            }
-            #[doc = "Bit 21 - Event Mask on line 21"]
-            #[inline]
-            pub fn mr21(&mut self) -> _MR21W {
-                _MR21W { w: self }
-            }
-            #[doc = "Bit 22 - Event Mask on line 22"]
-            #[inline]
-            pub fn mr22(&mut self) -> _MR22W {
-                _MR22W { w: self }
-            }
-        }
-    }
-    #[doc = "Rising Trigger selection register (EXTI_RTSR)"]
-    pub struct RTSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Rising Trigger selection register (EXTI_RTSR)"]
-    pub mod rtsr {
-        #[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::RTSR {
-            #[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 = r" Value of the field"]
-        pub struct TR0R {
-            bits: bool,
-        }
-        impl TR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR1R {
-            bits: bool,
-        }
-        impl TR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR2R {
-            bits: bool,
-        }
-        impl TR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR3R {
-            bits: bool,
-        }
-        impl TR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR4R {
-            bits: bool,
-        }
-        impl TR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR5R {
-            bits: bool,
-        }
-        impl TR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR6R {
-            bits: bool,
-        }
-        impl TR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR7R {
-            bits: bool,
-        }
-        impl TR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR8R {
-            bits: bool,
-        }
-        impl TR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR9R {
-            bits: bool,
-        }
-        impl TR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR10R {
-            bits: bool,
-        }
-        impl TR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR11R {
-            bits: bool,
-        }
-        impl TR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR12R {
-            bits: bool,
-        }
-        impl TR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR13R {
-            bits: bool,
-        }
-        impl TR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR14R {
-            bits: bool,
-        }
-        impl TR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR15R {
-            bits: bool,
-        }
-        impl TR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR16R {
-            bits: bool,
-        }
-        impl TR16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR17R {
-            bits: bool,
-        }
-        impl TR17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR18R {
-            bits: bool,
-        }
-        impl TR18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR19R {
-            bits: bool,
-        }
-        impl TR19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR20R {
-            bits: bool,
-        }
-        impl TR20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR21R {
-            bits: bool,
-        }
-        impl TR21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR22R {
-            bits: bool,
-        }
-        impl TR22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR22W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Rising trigger event configuration of line 0"]
-            #[inline]
-            pub fn tr0(&self) -> TR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR0R { bits }
-            }
-            #[doc = "Bit 1 - Rising trigger event configuration of line 1"]
-            #[inline]
-            pub fn tr1(&self) -> TR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR1R { bits }
-            }
-            #[doc = "Bit 2 - Rising trigger event configuration of line 2"]
-            #[inline]
-            pub fn tr2(&self) -> TR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR2R { bits }
-            }
-            #[doc = "Bit 3 - Rising trigger event configuration of line 3"]
-            #[inline]
-            pub fn tr3(&self) -> TR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR3R { bits }
-            }
-            #[doc = "Bit 4 - Rising trigger event configuration of line 4"]
-            #[inline]
-            pub fn tr4(&self) -> TR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR4R { bits }
-            }
-            #[doc = "Bit 5 - Rising trigger event configuration of line 5"]
-            #[inline]
-            pub fn tr5(&self) -> TR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR5R { bits }
-            }
-            #[doc = "Bit 6 - Rising trigger event configuration of line 6"]
-            #[inline]
-            pub fn tr6(&self) -> TR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR6R { bits }
-            }
-            #[doc = "Bit 7 - Rising trigger event configuration of line 7"]
-            #[inline]
-            pub fn tr7(&self) -> TR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR7R { bits }
-            }
-            #[doc = "Bit 8 - Rising trigger event configuration of line 8"]
-            #[inline]
-            pub fn tr8(&self) -> TR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR8R { bits }
-            }
-            #[doc = "Bit 9 - Rising trigger event configuration of line 9"]
-            #[inline]
-            pub fn tr9(&self) -> TR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR9R { bits }
-            }
-            #[doc = "Bit 10 - Rising trigger event configuration of line 10"]
-            #[inline]
-            pub fn tr10(&self) -> TR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR10R { bits }
-            }
-            #[doc = "Bit 11 - Rising trigger event configuration of line 11"]
-            #[inline]
-            pub fn tr11(&self) -> TR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR11R { bits }
-            }
-            #[doc = "Bit 12 - Rising trigger event configuration of line 12"]
-            #[inline]
-            pub fn tr12(&self) -> TR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR12R { bits }
-            }
-            #[doc = "Bit 13 - Rising trigger event configuration of line 13"]
-            #[inline]
-            pub fn tr13(&self) -> TR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR13R { bits }
-            }
-            #[doc = "Bit 14 - Rising trigger event configuration of line 14"]
-            #[inline]
-            pub fn tr14(&self) -> TR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR14R { bits }
-            }
-            #[doc = "Bit 15 - Rising trigger event configuration of line 15"]
-            #[inline]
-            pub fn tr15(&self) -> TR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR15R { bits }
-            }
-            #[doc = "Bit 16 - Rising trigger event configuration of line 16"]
-            #[inline]
-            pub fn tr16(&self) -> TR16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR16R { bits }
-            }
-            #[doc = "Bit 17 - Rising trigger event configuration of line 17"]
-            #[inline]
-            pub fn tr17(&self) -> TR17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR17R { bits }
-            }
-            #[doc = "Bit 18 - Rising trigger event configuration of line 18"]
-            #[inline]
-            pub fn tr18(&self) -> TR18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR18R { bits }
-            }
-            #[doc = "Bit 19 - Rising trigger event configuration of line 19"]
-            #[inline]
-            pub fn tr19(&self) -> TR19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR19R { bits }
-            }
-            #[doc = "Bit 20 - Rising trigger event configuration of line 20"]
-            #[inline]
-            pub fn tr20(&self) -> TR20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR20R { bits }
-            }
-            #[doc = "Bit 21 - Rising trigger event configuration of line 21"]
-            #[inline]
-            pub fn tr21(&self) -> TR21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR21R { bits }
-            }
-            #[doc = "Bit 22 - Rising trigger event configuration of line 22"]
-            #[inline]
-            pub fn tr22(&self) -> TR22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR22R { bits }
-            }
-        }
-        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 - Rising trigger event configuration of line 0"]
-            #[inline]
-            pub fn tr0(&mut self) -> _TR0W {
-                _TR0W { w: self }
-            }
-            #[doc = "Bit 1 - Rising trigger event configuration of line 1"]
-            #[inline]
-            pub fn tr1(&mut self) -> _TR1W {
-                _TR1W { w: self }
-            }
-            #[doc = "Bit 2 - Rising trigger event configuration of line 2"]
-            #[inline]
-            pub fn tr2(&mut self) -> _TR2W {
-                _TR2W { w: self }
-            }
-            #[doc = "Bit 3 - Rising trigger event configuration of line 3"]
-            #[inline]
-            pub fn tr3(&mut self) -> _TR3W {
-                _TR3W { w: self }
-            }
-            #[doc = "Bit 4 - Rising trigger event configuration of line 4"]
-            #[inline]
-            pub fn tr4(&mut self) -> _TR4W {
-                _TR4W { w: self }
-            }
-            #[doc = "Bit 5 - Rising trigger event configuration of line 5"]
-            #[inline]
-            pub fn tr5(&mut self) -> _TR5W {
-                _TR5W { w: self }
-            }
-            #[doc = "Bit 6 - Rising trigger event configuration of line 6"]
-            #[inline]
-            pub fn tr6(&mut self) -> _TR6W {
-                _TR6W { w: self }
-            }
-            #[doc = "Bit 7 - Rising trigger event configuration of line 7"]
-            #[inline]
-            pub fn tr7(&mut self) -> _TR7W {
-                _TR7W { w: self }
-            }
-            #[doc = "Bit 8 - Rising trigger event configuration of line 8"]
-            #[inline]
-            pub fn tr8(&mut self) -> _TR8W {
-                _TR8W { w: self }
-            }
-            #[doc = "Bit 9 - Rising trigger event configuration of line 9"]
-            #[inline]
-            pub fn tr9(&mut self) -> _TR9W {
-                _TR9W { w: self }
-            }
-            #[doc = "Bit 10 - Rising trigger event configuration of line 10"]
-            #[inline]
-            pub fn tr10(&mut self) -> _TR10W {
-                _TR10W { w: self }
-            }
-            #[doc = "Bit 11 - Rising trigger event configuration of line 11"]
-            #[inline]
-            pub fn tr11(&mut self) -> _TR11W {
-                _TR11W { w: self }
-            }
-            #[doc = "Bit 12 - Rising trigger event configuration of line 12"]
-            #[inline]
-            pub fn tr12(&mut self) -> _TR12W {
-                _TR12W { w: self }
-            }
-            #[doc = "Bit 13 - Rising trigger event configuration of line 13"]
-            #[inline]
-            pub fn tr13(&mut self) -> _TR13W {
-                _TR13W { w: self }
-            }
-            #[doc = "Bit 14 - Rising trigger event configuration of line 14"]
-            #[inline]
-            pub fn tr14(&mut self) -> _TR14W {
-                _TR14W { w: self }
-            }
-            #[doc = "Bit 15 - Rising trigger event configuration of line 15"]
-            #[inline]
-            pub fn tr15(&mut self) -> _TR15W {
-                _TR15W { w: self }
-            }
-            #[doc = "Bit 16 - Rising trigger event configuration of line 16"]
-            #[inline]
-            pub fn tr16(&mut self) -> _TR16W {
-                _TR16W { w: self }
-            }
-            #[doc = "Bit 17 - Rising trigger event configuration of line 17"]
-            #[inline]
-            pub fn tr17(&mut self) -> _TR17W {
-                _TR17W { w: self }
-            }
-            #[doc = "Bit 18 - Rising trigger event configuration of line 18"]
-            #[inline]
-            pub fn tr18(&mut self) -> _TR18W {
-                _TR18W { w: self }
-            }
-            #[doc = "Bit 19 - Rising trigger event configuration of line 19"]
-            #[inline]
-            pub fn tr19(&mut self) -> _TR19W {
-                _TR19W { w: self }
-            }
-            #[doc = "Bit 20 - Rising trigger event configuration of line 20"]
-            #[inline]
-            pub fn tr20(&mut self) -> _TR20W {
-                _TR20W { w: self }
-            }
-            #[doc = "Bit 21 - Rising trigger event configuration of line 21"]
-            #[inline]
-            pub fn tr21(&mut self) -> _TR21W {
-                _TR21W { w: self }
-            }
-            #[doc = "Bit 22 - Rising trigger event configuration of line 22"]
-            #[inline]
-            pub fn tr22(&mut self) -> _TR22W {
-                _TR22W { w: self }
-            }
-        }
-    }
-    #[doc = "Falling Trigger selection register (EXTI_FTSR)"]
-    pub struct FTSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Falling Trigger selection register (EXTI_FTSR)"]
-    pub mod ftsr {
-        #[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::FTSR {
-            #[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 = r" Value of the field"]
-        pub struct TR0R {
-            bits: bool,
-        }
-        impl TR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR1R {
-            bits: bool,
-        }
-        impl TR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR2R {
-            bits: bool,
-        }
-        impl TR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR3R {
-            bits: bool,
-        }
-        impl TR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR4R {
-            bits: bool,
-        }
-        impl TR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR5R {
-            bits: bool,
-        }
-        impl TR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR6R {
-            bits: bool,
-        }
-        impl TR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR7R {
-            bits: bool,
-        }
-        impl TR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR8R {
-            bits: bool,
-        }
-        impl TR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR9R {
-            bits: bool,
-        }
-        impl TR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR10R {
-            bits: bool,
-        }
-        impl TR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR11R {
-            bits: bool,
-        }
-        impl TR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR12R {
-            bits: bool,
-        }
-        impl TR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR13R {
-            bits: bool,
-        }
-        impl TR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR14R {
-            bits: bool,
-        }
-        impl TR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR15R {
-            bits: bool,
-        }
-        impl TR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR16R {
-            bits: bool,
-        }
-        impl TR16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR17R {
-            bits: bool,
-        }
-        impl TR17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR18R {
-            bits: bool,
-        }
-        impl TR18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR19R {
-            bits: bool,
-        }
-        impl TR19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR20R {
-            bits: bool,
-        }
-        impl TR20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR21R {
-            bits: bool,
-        }
-        impl TR21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR22R {
-            bits: bool,
-        }
-        impl TR22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TR22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TR22W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Falling trigger event configuration of line 0"]
-            #[inline]
-            pub fn tr0(&self) -> TR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR0R { bits }
-            }
-            #[doc = "Bit 1 - Falling trigger event configuration of line 1"]
-            #[inline]
-            pub fn tr1(&self) -> TR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR1R { bits }
-            }
-            #[doc = "Bit 2 - Falling trigger event configuration of line 2"]
-            #[inline]
-            pub fn tr2(&self) -> TR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR2R { bits }
-            }
-            #[doc = "Bit 3 - Falling trigger event configuration of line 3"]
-            #[inline]
-            pub fn tr3(&self) -> TR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR3R { bits }
-            }
-            #[doc = "Bit 4 - Falling trigger event configuration of line 4"]
-            #[inline]
-            pub fn tr4(&self) -> TR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR4R { bits }
-            }
-            #[doc = "Bit 5 - Falling trigger event configuration of line 5"]
-            #[inline]
-            pub fn tr5(&self) -> TR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR5R { bits }
-            }
-            #[doc = "Bit 6 - Falling trigger event configuration of line 6"]
-            #[inline]
-            pub fn tr6(&self) -> TR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR6R { bits }
-            }
-            #[doc = "Bit 7 - Falling trigger event configuration of line 7"]
-            #[inline]
-            pub fn tr7(&self) -> TR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR7R { bits }
-            }
-            #[doc = "Bit 8 - Falling trigger event configuration of line 8"]
-            #[inline]
-            pub fn tr8(&self) -> TR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR8R { bits }
-            }
-            #[doc = "Bit 9 - Falling trigger event configuration of line 9"]
-            #[inline]
-            pub fn tr9(&self) -> TR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR9R { bits }
-            }
-            #[doc = "Bit 10 - Falling trigger event configuration of line 10"]
-            #[inline]
-            pub fn tr10(&self) -> TR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR10R { bits }
-            }
-            #[doc = "Bit 11 - Falling trigger event configuration of line 11"]
-            #[inline]
-            pub fn tr11(&self) -> TR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR11R { bits }
-            }
-            #[doc = "Bit 12 - Falling trigger event configuration of line 12"]
-            #[inline]
-            pub fn tr12(&self) -> TR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR12R { bits }
-            }
-            #[doc = "Bit 13 - Falling trigger event configuration of line 13"]
-            #[inline]
-            pub fn tr13(&self) -> TR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR13R { bits }
-            }
-            #[doc = "Bit 14 - Falling trigger event configuration of line 14"]
-            #[inline]
-            pub fn tr14(&self) -> TR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR14R { bits }
-            }
-            #[doc = "Bit 15 - Falling trigger event configuration of line 15"]
-            #[inline]
-            pub fn tr15(&self) -> TR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR15R { bits }
-            }
-            #[doc = "Bit 16 - Falling trigger event configuration of line 16"]
-            #[inline]
-            pub fn tr16(&self) -> TR16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR16R { bits }
-            }
-            #[doc = "Bit 17 - Falling trigger event configuration of line 17"]
-            #[inline]
-            pub fn tr17(&self) -> TR17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR17R { bits }
-            }
-            #[doc = "Bit 18 - Falling trigger event configuration of line 18"]
-            #[inline]
-            pub fn tr18(&self) -> TR18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR18R { bits }
-            }
-            #[doc = "Bit 19 - Falling trigger event configuration of line 19"]
-            #[inline]
-            pub fn tr19(&self) -> TR19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR19R { bits }
-            }
-            #[doc = "Bit 20 - Falling trigger event configuration of line 20"]
-            #[inline]
-            pub fn tr20(&self) -> TR20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR20R { bits }
-            }
-            #[doc = "Bit 21 - Falling trigger event configuration of line 21"]
-            #[inline]
-            pub fn tr21(&self) -> TR21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR21R { bits }
-            }
-            #[doc = "Bit 22 - Falling trigger event configuration of line 22"]
-            #[inline]
-            pub fn tr22(&self) -> TR22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TR22R { bits }
-            }
-        }
-        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 - Falling trigger event configuration of line 0"]
-            #[inline]
-            pub fn tr0(&mut self) -> _TR0W {
-                _TR0W { w: self }
-            }
-            #[doc = "Bit 1 - Falling trigger event configuration of line 1"]
-            #[inline]
-            pub fn tr1(&mut self) -> _TR1W {
-                _TR1W { w: self }
-            }
-            #[doc = "Bit 2 - Falling trigger event configuration of line 2"]
-            #[inline]
-            pub fn tr2(&mut self) -> _TR2W {
-                _TR2W { w: self }
-            }
-            #[doc = "Bit 3 - Falling trigger event configuration of line 3"]
-            #[inline]
-            pub fn tr3(&mut self) -> _TR3W {
-                _TR3W { w: self }
-            }
-            #[doc = "Bit 4 - Falling trigger event configuration of line 4"]
-            #[inline]
-            pub fn tr4(&mut self) -> _TR4W {
-                _TR4W { w: self }
-            }
-            #[doc = "Bit 5 - Falling trigger event configuration of line 5"]
-            #[inline]
-            pub fn tr5(&mut self) -> _TR5W {
-                _TR5W { w: self }
-            }
-            #[doc = "Bit 6 - Falling trigger event configuration of line 6"]
-            #[inline]
-            pub fn tr6(&mut self) -> _TR6W {
-                _TR6W { w: self }
-            }
-            #[doc = "Bit 7 - Falling trigger event configuration of line 7"]
-            #[inline]
-            pub fn tr7(&mut self) -> _TR7W {
-                _TR7W { w: self }
-            }
-            #[doc = "Bit 8 - Falling trigger event configuration of line 8"]
-            #[inline]
-            pub fn tr8(&mut self) -> _TR8W {
-                _TR8W { w: self }
-            }
-            #[doc = "Bit 9 - Falling trigger event configuration of line 9"]
-            #[inline]
-            pub fn tr9(&mut self) -> _TR9W {
-                _TR9W { w: self }
-            }
-            #[doc = "Bit 10 - Falling trigger event configuration of line 10"]
-            #[inline]
-            pub fn tr10(&mut self) -> _TR10W {
-                _TR10W { w: self }
-            }
-            #[doc = "Bit 11 - Falling trigger event configuration of line 11"]
-            #[inline]
-            pub fn tr11(&mut self) -> _TR11W {
-                _TR11W { w: self }
-            }
-            #[doc = "Bit 12 - Falling trigger event configuration of line 12"]
-            #[inline]
-            pub fn tr12(&mut self) -> _TR12W {
-                _TR12W { w: self }
-            }
-            #[doc = "Bit 13 - Falling trigger event configuration of line 13"]
-            #[inline]
-            pub fn tr13(&mut self) -> _TR13W {
-                _TR13W { w: self }
-            }
-            #[doc = "Bit 14 - Falling trigger event configuration of line 14"]
-            #[inline]
-            pub fn tr14(&mut self) -> _TR14W {
-                _TR14W { w: self }
-            }
-            #[doc = "Bit 15 - Falling trigger event configuration of line 15"]
-            #[inline]
-            pub fn tr15(&mut self) -> _TR15W {
-                _TR15W { w: self }
-            }
-            #[doc = "Bit 16 - Falling trigger event configuration of line 16"]
-            #[inline]
-            pub fn tr16(&mut self) -> _TR16W {
-                _TR16W { w: self }
-            }
-            #[doc = "Bit 17 - Falling trigger event configuration of line 17"]
-            #[inline]
-            pub fn tr17(&mut self) -> _TR17W {
-                _TR17W { w: self }
-            }
-            #[doc = "Bit 18 - Falling trigger event configuration of line 18"]
-            #[inline]
-            pub fn tr18(&mut self) -> _TR18W {
-                _TR18W { w: self }
-            }
-            #[doc = "Bit 19 - Falling trigger event configuration of line 19"]
-            #[inline]
-            pub fn tr19(&mut self) -> _TR19W {
-                _TR19W { w: self }
-            }
-            #[doc = "Bit 20 - Falling trigger event configuration of line 20"]
-            #[inline]
-            pub fn tr20(&mut self) -> _TR20W {
-                _TR20W { w: self }
-            }
-            #[doc = "Bit 21 - Falling trigger event configuration of line 21"]
-            #[inline]
-            pub fn tr21(&mut self) -> _TR21W {
-                _TR21W { w: self }
-            }
-            #[doc = "Bit 22 - Falling trigger event configuration of line 22"]
-            #[inline]
-            pub fn tr22(&mut self) -> _TR22W {
-                _TR22W { w: self }
-            }
-        }
-    }
-    #[doc = "Software interrupt event register (EXTI_SWIER)"]
-    pub struct SWIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Software interrupt event register (EXTI_SWIER)"]
-    pub mod swier {
-        #[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::SWIER {
-            #[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 = r" Value of the field"]
-        pub struct SWIER0R {
-            bits: bool,
-        }
-        impl SWIER0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER1R {
-            bits: bool,
-        }
-        impl SWIER1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER2R {
-            bits: bool,
-        }
-        impl SWIER2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER3R {
-            bits: bool,
-        }
-        impl SWIER3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER4R {
-            bits: bool,
-        }
-        impl SWIER4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER5R {
-            bits: bool,
-        }
-        impl SWIER5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER6R {
-            bits: bool,
-        }
-        impl SWIER6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER7R {
-            bits: bool,
-        }
-        impl SWIER7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER8R {
-            bits: bool,
-        }
-        impl SWIER8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER9R {
-            bits: bool,
-        }
-        impl SWIER9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER10R {
-            bits: bool,
-        }
-        impl SWIER10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER11R {
-            bits: bool,
-        }
-        impl SWIER11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER12R {
-            bits: bool,
-        }
-        impl SWIER12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER13R {
-            bits: bool,
-        }
-        impl SWIER13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER14R {
-            bits: bool,
-        }
-        impl SWIER14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER15R {
-            bits: bool,
-        }
-        impl SWIER15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER16R {
-            bits: bool,
-        }
-        impl SWIER16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER17R {
-            bits: bool,
-        }
-        impl SWIER17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER18R {
-            bits: bool,
-        }
-        impl SWIER18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER19R {
-            bits: bool,
-        }
-        impl SWIER19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER20R {
-            bits: bool,
-        }
-        impl SWIER20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER21R {
-            bits: bool,
-        }
-        impl SWIER21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWIER22R {
-            bits: bool,
-        }
-        impl SWIER22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SWIER0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWIER22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWIER22W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Software Interrupt on line 0"]
-            #[inline]
-            pub fn swier0(&self) -> SWIER0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER0R { bits }
-            }
-            #[doc = "Bit 1 - Software Interrupt on line 1"]
-            #[inline]
-            pub fn swier1(&self) -> SWIER1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER1R { bits }
-            }
-            #[doc = "Bit 2 - Software Interrupt on line 2"]
-            #[inline]
-            pub fn swier2(&self) -> SWIER2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER2R { bits }
-            }
-            #[doc = "Bit 3 - Software Interrupt on line 3"]
-            #[inline]
-            pub fn swier3(&self) -> SWIER3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER3R { bits }
-            }
-            #[doc = "Bit 4 - Software Interrupt on line 4"]
-            #[inline]
-            pub fn swier4(&self) -> SWIER4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER4R { bits }
-            }
-            #[doc = "Bit 5 - Software Interrupt on line 5"]
-            #[inline]
-            pub fn swier5(&self) -> SWIER5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER5R { bits }
-            }
-            #[doc = "Bit 6 - Software Interrupt on line 6"]
-            #[inline]
-            pub fn swier6(&self) -> SWIER6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER6R { bits }
-            }
-            #[doc = "Bit 7 - Software Interrupt on line 7"]
-            #[inline]
-            pub fn swier7(&self) -> SWIER7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER7R { bits }
-            }
-            #[doc = "Bit 8 - Software Interrupt on line 8"]
-            #[inline]
-            pub fn swier8(&self) -> SWIER8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER8R { bits }
-            }
-            #[doc = "Bit 9 - Software Interrupt on line 9"]
-            #[inline]
-            pub fn swier9(&self) -> SWIER9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER9R { bits }
-            }
-            #[doc = "Bit 10 - Software Interrupt on line 10"]
-            #[inline]
-            pub fn swier10(&self) -> SWIER10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER10R { bits }
-            }
-            #[doc = "Bit 11 - Software Interrupt on line 11"]
-            #[inline]
-            pub fn swier11(&self) -> SWIER11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER11R { bits }
-            }
-            #[doc = "Bit 12 - Software Interrupt on line 12"]
-            #[inline]
-            pub fn swier12(&self) -> SWIER12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER12R { bits }
-            }
-            #[doc = "Bit 13 - Software Interrupt on line 13"]
-            #[inline]
-            pub fn swier13(&self) -> SWIER13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER13R { bits }
-            }
-            #[doc = "Bit 14 - Software Interrupt on line 14"]
-            #[inline]
-            pub fn swier14(&self) -> SWIER14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER14R { bits }
-            }
-            #[doc = "Bit 15 - Software Interrupt on line 15"]
-            #[inline]
-            pub fn swier15(&self) -> SWIER15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER15R { bits }
-            }
-            #[doc = "Bit 16 - Software Interrupt on line 16"]
-            #[inline]
-            pub fn swier16(&self) -> SWIER16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER16R { bits }
-            }
-            #[doc = "Bit 17 - Software Interrupt on line 17"]
-            #[inline]
-            pub fn swier17(&self) -> SWIER17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER17R { bits }
-            }
-            #[doc = "Bit 18 - Software Interrupt on line 18"]
-            #[inline]
-            pub fn swier18(&self) -> SWIER18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER18R { bits }
-            }
-            #[doc = "Bit 19 - Software Interrupt on line 19"]
-            #[inline]
-            pub fn swier19(&self) -> SWIER19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER19R { bits }
-            }
-            #[doc = "Bit 20 - Software Interrupt on line 20"]
-            #[inline]
-            pub fn swier20(&self) -> SWIER20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER20R { bits }
-            }
-            #[doc = "Bit 21 - Software Interrupt on line 21"]
-            #[inline]
-            pub fn swier21(&self) -> SWIER21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER21R { bits }
-            }
-            #[doc = "Bit 22 - Software Interrupt on line 22"]
-            #[inline]
-            pub fn swier22(&self) -> SWIER22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWIER22R { bits }
-            }
-        }
-        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 - Software Interrupt on line 0"]
-            #[inline]
-            pub fn swier0(&mut self) -> _SWIER0W {
-                _SWIER0W { w: self }
-            }
-            #[doc = "Bit 1 - Software Interrupt on line 1"]
-            #[inline]
-            pub fn swier1(&mut self) -> _SWIER1W {
-                _SWIER1W { w: self }
-            }
-            #[doc = "Bit 2 - Software Interrupt on line 2"]
-            #[inline]
-            pub fn swier2(&mut self) -> _SWIER2W {
-                _SWIER2W { w: self }
-            }
-            #[doc = "Bit 3 - Software Interrupt on line 3"]
-            #[inline]
-            pub fn swier3(&mut self) -> _SWIER3W {
-                _SWIER3W { w: self }
-            }
-            #[doc = "Bit 4 - Software Interrupt on line 4"]
-            #[inline]
-            pub fn swier4(&mut self) -> _SWIER4W {
-                _SWIER4W { w: self }
-            }
-            #[doc = "Bit 5 - Software Interrupt on line 5"]
-            #[inline]
-            pub fn swier5(&mut self) -> _SWIER5W {
-                _SWIER5W { w: self }
-            }
-            #[doc = "Bit 6 - Software Interrupt on line 6"]
-            #[inline]
-            pub fn swier6(&mut self) -> _SWIER6W {
-                _SWIER6W { w: self }
-            }
-            #[doc = "Bit 7 - Software Interrupt on line 7"]
-            #[inline]
-            pub fn swier7(&mut self) -> _SWIER7W {
-                _SWIER7W { w: self }
-            }
-            #[doc = "Bit 8 - Software Interrupt on line 8"]
-            #[inline]
-            pub fn swier8(&mut self) -> _SWIER8W {
-                _SWIER8W { w: self }
-            }
-            #[doc = "Bit 9 - Software Interrupt on line 9"]
-            #[inline]
-            pub fn swier9(&mut self) -> _SWIER9W {
-                _SWIER9W { w: self }
-            }
-            #[doc = "Bit 10 - Software Interrupt on line 10"]
-            #[inline]
-            pub fn swier10(&mut self) -> _SWIER10W {
-                _SWIER10W { w: self }
-            }
-            #[doc = "Bit 11 - Software Interrupt on line 11"]
-            #[inline]
-            pub fn swier11(&mut self) -> _SWIER11W {
-                _SWIER11W { w: self }
-            }
-            #[doc = "Bit 12 - Software Interrupt on line 12"]
-            #[inline]
-            pub fn swier12(&mut self) -> _SWIER12W {
-                _SWIER12W { w: self }
-            }
-            #[doc = "Bit 13 - Software Interrupt on line 13"]
-            #[inline]
-            pub fn swier13(&mut self) -> _SWIER13W {
-                _SWIER13W { w: self }
-            }
-            #[doc = "Bit 14 - Software Interrupt on line 14"]
-            #[inline]
-            pub fn swier14(&mut self) -> _SWIER14W {
-                _SWIER14W { w: self }
-            }
-            #[doc = "Bit 15 - Software Interrupt on line 15"]
-            #[inline]
-            pub fn swier15(&mut self) -> _SWIER15W {
-                _SWIER15W { w: self }
-            }
-            #[doc = "Bit 16 - Software Interrupt on line 16"]
-            #[inline]
-            pub fn swier16(&mut self) -> _SWIER16W {
-                _SWIER16W { w: self }
-            }
-            #[doc = "Bit 17 - Software Interrupt on line 17"]
-            #[inline]
-            pub fn swier17(&mut self) -> _SWIER17W {
-                _SWIER17W { w: self }
-            }
-            #[doc = "Bit 18 - Software Interrupt on line 18"]
-            #[inline]
-            pub fn swier18(&mut self) -> _SWIER18W {
-                _SWIER18W { w: self }
-            }
-            #[doc = "Bit 19 - Software Interrupt on line 19"]
-            #[inline]
-            pub fn swier19(&mut self) -> _SWIER19W {
-                _SWIER19W { w: self }
-            }
-            #[doc = "Bit 20 - Software Interrupt on line 20"]
-            #[inline]
-            pub fn swier20(&mut self) -> _SWIER20W {
-                _SWIER20W { w: self }
-            }
-            #[doc = "Bit 21 - Software Interrupt on line 21"]
-            #[inline]
-            pub fn swier21(&mut self) -> _SWIER21W {
-                _SWIER21W { w: self }
-            }
-            #[doc = "Bit 22 - Software Interrupt on line 22"]
-            #[inline]
-            pub fn swier22(&mut self) -> _SWIER22W {
-                _SWIER22W { w: self }
-            }
-        }
-    }
-    #[doc = "Pending register (EXTI_PR)"]
-    pub struct PR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Pending register (EXTI_PR)"]
-    pub mod pr {
-        #[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::PR {
-            #[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 = r" Value of the field"]
-        pub struct PR0R {
-            bits: bool,
-        }
-        impl PR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR1R {
-            bits: bool,
-        }
-        impl PR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR2R {
-            bits: bool,
-        }
-        impl PR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR3R {
-            bits: bool,
-        }
-        impl PR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR4R {
-            bits: bool,
-        }
-        impl PR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR5R {
-            bits: bool,
-        }
-        impl PR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR6R {
-            bits: bool,
-        }
-        impl PR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR7R {
-            bits: bool,
-        }
-        impl PR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR8R {
-            bits: bool,
-        }
-        impl PR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR9R {
-            bits: bool,
-        }
-        impl PR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR10R {
-            bits: bool,
-        }
-        impl PR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR11R {
-            bits: bool,
-        }
-        impl PR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR12R {
-            bits: bool,
-        }
-        impl PR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR13R {
-            bits: bool,
-        }
-        impl PR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR14R {
-            bits: bool,
-        }
-        impl PR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR15R {
-            bits: bool,
-        }
-        impl PR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR16R {
-            bits: bool,
-        }
-        impl PR16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR17R {
-            bits: bool,
-        }
-        impl PR17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR18R {
-            bits: bool,
-        }
-        impl PR18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR19R {
-            bits: bool,
-        }
-        impl PR19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR20R {
-            bits: bool,
-        }
-        impl PR20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR21R {
-            bits: bool,
-        }
-        impl PR21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PR22R {
-            bits: bool,
-        }
-        impl PR22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _PR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PR22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PR22W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Pending bit 0"]
-            #[inline]
-            pub fn pr0(&self) -> PR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR0R { bits }
-            }
-            #[doc = "Bit 1 - Pending bit 1"]
-            #[inline]
-            pub fn pr1(&self) -> PR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR1R { bits }
-            }
-            #[doc = "Bit 2 - Pending bit 2"]
-            #[inline]
-            pub fn pr2(&self) -> PR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR2R { bits }
-            }
-            #[doc = "Bit 3 - Pending bit 3"]
-            #[inline]
-            pub fn pr3(&self) -> PR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR3R { bits }
-            }
-            #[doc = "Bit 4 - Pending bit 4"]
-            #[inline]
-            pub fn pr4(&self) -> PR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR4R { bits }
-            }
-            #[doc = "Bit 5 - Pending bit 5"]
-            #[inline]
-            pub fn pr5(&self) -> PR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR5R { bits }
-            }
-            #[doc = "Bit 6 - Pending bit 6"]
-            #[inline]
-            pub fn pr6(&self) -> PR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR6R { bits }
-            }
-            #[doc = "Bit 7 - Pending bit 7"]
-            #[inline]
-            pub fn pr7(&self) -> PR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR7R { bits }
-            }
-            #[doc = "Bit 8 - Pending bit 8"]
-            #[inline]
-            pub fn pr8(&self) -> PR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR8R { bits }
-            }
-            #[doc = "Bit 9 - Pending bit 9"]
-            #[inline]
-            pub fn pr9(&self) -> PR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR9R { bits }
-            }
-            #[doc = "Bit 10 - Pending bit 10"]
-            #[inline]
-            pub fn pr10(&self) -> PR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR10R { bits }
-            }
-            #[doc = "Bit 11 - Pending bit 11"]
-            #[inline]
-            pub fn pr11(&self) -> PR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR11R { bits }
-            }
-            #[doc = "Bit 12 - Pending bit 12"]
-            #[inline]
-            pub fn pr12(&self) -> PR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR12R { bits }
-            }
-            #[doc = "Bit 13 - Pending bit 13"]
-            #[inline]
-            pub fn pr13(&self) -> PR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR13R { bits }
-            }
-            #[doc = "Bit 14 - Pending bit 14"]
-            #[inline]
-            pub fn pr14(&self) -> PR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR14R { bits }
-            }
-            #[doc = "Bit 15 - Pending bit 15"]
-            #[inline]
-            pub fn pr15(&self) -> PR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR15R { bits }
-            }
-            #[doc = "Bit 16 - Pending bit 16"]
-            #[inline]
-            pub fn pr16(&self) -> PR16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR16R { bits }
-            }
-            #[doc = "Bit 17 - Pending bit 17"]
-            #[inline]
-            pub fn pr17(&self) -> PR17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR17R { bits }
-            }
-            #[doc = "Bit 18 - Pending bit 18"]
-            #[inline]
-            pub fn pr18(&self) -> PR18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR18R { bits }
-            }
-            #[doc = "Bit 19 - Pending bit 19"]
-            #[inline]
-            pub fn pr19(&self) -> PR19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR19R { bits }
-            }
-            #[doc = "Bit 20 - Pending bit 20"]
-            #[inline]
-            pub fn pr20(&self) -> PR20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR20R { bits }
-            }
-            #[doc = "Bit 21 - Pending bit 21"]
-            #[inline]
-            pub fn pr21(&self) -> PR21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR21R { bits }
-            }
-            #[doc = "Bit 22 - Pending bit 22"]
-            #[inline]
-            pub fn pr22(&self) -> PR22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PR22R { bits }
-            }
-        }
-        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 - Pending bit 0"]
-            #[inline]
-            pub fn pr0(&mut self) -> _PR0W {
-                _PR0W { w: self }
-            }
-            #[doc = "Bit 1 - Pending bit 1"]
-            #[inline]
-            pub fn pr1(&mut self) -> _PR1W {
-                _PR1W { w: self }
-            }
-            #[doc = "Bit 2 - Pending bit 2"]
-            #[inline]
-            pub fn pr2(&mut self) -> _PR2W {
-                _PR2W { w: self }
-            }
-            #[doc = "Bit 3 - Pending bit 3"]
-            #[inline]
-            pub fn pr3(&mut self) -> _PR3W {
-                _PR3W { w: self }
-            }
-            #[doc = "Bit 4 - Pending bit 4"]
-            #[inline]
-            pub fn pr4(&mut self) -> _PR4W {
-                _PR4W { w: self }
-            }
-            #[doc = "Bit 5 - Pending bit 5"]
-            #[inline]
-            pub fn pr5(&mut self) -> _PR5W {
-                _PR5W { w: self }
-            }
-            #[doc = "Bit 6 - Pending bit 6"]
-            #[inline]
-            pub fn pr6(&mut self) -> _PR6W {
-                _PR6W { w: self }
-            }
-            #[doc = "Bit 7 - Pending bit 7"]
-            #[inline]
-            pub fn pr7(&mut self) -> _PR7W {
-                _PR7W { w: self }
-            }
-            #[doc = "Bit 8 - Pending bit 8"]
-            #[inline]
-            pub fn pr8(&mut self) -> _PR8W {
-                _PR8W { w: self }
-            }
-            #[doc = "Bit 9 - Pending bit 9"]
-            #[inline]
-            pub fn pr9(&mut self) -> _PR9W {
-                _PR9W { w: self }
-            }
-            #[doc = "Bit 10 - Pending bit 10"]
-            #[inline]
-            pub fn pr10(&mut self) -> _PR10W {
-                _PR10W { w: self }
-            }
-            #[doc = "Bit 11 - Pending bit 11"]
-            #[inline]
-            pub fn pr11(&mut self) -> _PR11W {
-                _PR11W { w: self }
-            }
-            #[doc = "Bit 12 - Pending bit 12"]
-            #[inline]
-            pub fn pr12(&mut self) -> _PR12W {
-                _PR12W { w: self }
-            }
-            #[doc = "Bit 13 - Pending bit 13"]
-            #[inline]
-            pub fn pr13(&mut self) -> _PR13W {
-                _PR13W { w: self }
-            }
-            #[doc = "Bit 14 - Pending bit 14"]
-            #[inline]
-            pub fn pr14(&mut self) -> _PR14W {
-                _PR14W { w: self }
-            }
-            #[doc = "Bit 15 - Pending bit 15"]
-            #[inline]
-            pub fn pr15(&mut self) -> _PR15W {
-                _PR15W { w: self }
-            }
-            #[doc = "Bit 16 - Pending bit 16"]
-            #[inline]
-            pub fn pr16(&mut self) -> _PR16W {
-                _PR16W { w: self }
-            }
-            #[doc = "Bit 17 - Pending bit 17"]
-            #[inline]
-            pub fn pr17(&mut self) -> _PR17W {
-                _PR17W { w: self }
-            }
-            #[doc = "Bit 18 - Pending bit 18"]
-            #[inline]
-            pub fn pr18(&mut self) -> _PR18W {
-                _PR18W { w: self }
-            }
-            #[doc = "Bit 19 - Pending bit 19"]
-            #[inline]
-            pub fn pr19(&mut self) -> _PR19W {
-                _PR19W { w: self }
-            }
-            #[doc = "Bit 20 - Pending bit 20"]
-            #[inline]
-            pub fn pr20(&mut self) -> _PR20W {
-                _PR20W { w: self }
-            }
-            #[doc = "Bit 21 - Pending bit 21"]
-            #[inline]
-            pub fn pr21(&mut self) -> _PR21W {
-                _PR21W { w: self }
-            }
-            #[doc = "Bit 22 - Pending bit 22"]
-            #[inline]
-            pub fn pr22(&mut self) -> _PR22W {
-                _PR22W { w: self }
-            }
-        }
-    }
-}
-#[doc = "FLASH"]
-pub struct FLASH {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for FLASH {}
-impl FLASH {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const flash::RegisterBlock {
-        0x4002_3c00 as *const _
-    }
-}
-impl Deref for FLASH {
-    type Target = flash::RegisterBlock;
-    fn deref(&self) -> &flash::RegisterBlock {
-        unsafe { &*FLASH::ptr() }
-    }
-}
-#[doc = "FLASH"]
-pub mod flash {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Flash access control register"]
-        pub acr: ACR,
-        #[doc = "0x04 - Flash key register"]
-        pub keyr: KEYR,
-        #[doc = "0x08 - Flash option key register"]
-        pub optkeyr: OPTKEYR,
-        #[doc = "0x0c - Status register"]
-        pub sr: SR,
-        #[doc = "0x10 - Control register"]
-        pub cr: CR,
-        #[doc = "0x14 - Flash option control register"]
-        pub optcr: OPTCR,
-    }
-    #[doc = "Flash access control register"]
-    pub struct ACR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Flash access control register"]
-    pub mod acr {
-        #[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::ACR {
-            #[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 = r" Value of the field"]
-        pub struct LATENCYR {
-            bits: u8,
-        }
-        impl LATENCYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PRFTENR {
-            bits: bool,
-        }
-        impl PRFTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ICENR {
-            bits: bool,
-        }
-        impl ICENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DCENR {
-            bits: bool,
-        }
-        impl DCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DCRSTR {
-            bits: bool,
-        }
-        impl DCRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LATENCYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LATENCYW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PRFTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRFTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ICENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ICRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DCRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCRSTW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:2 - Latency"]
-            #[inline]
-            pub fn latency(&self) -> LATENCYR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                LATENCYR { bits }
-            }
-            #[doc = "Bit 8 - Prefetch enable"]
-            #[inline]
-            pub fn prften(&self) -> PRFTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PRFTENR { bits }
-            }
-            #[doc = "Bit 9 - Instruction cache enable"]
-            #[inline]
-            pub fn icen(&self) -> ICENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ICENR { bits }
-            }
-            #[doc = "Bit 10 - Data cache enable"]
-            #[inline]
-            pub fn dcen(&self) -> DCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCENR { bits }
-            }
-            #[doc = "Bit 12 - Data cache reset"]
-            #[inline]
-            pub fn dcrst(&self) -> DCRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCRSTR { bits }
-            }
-        }
-        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 0:2 - Latency"]
-            #[inline]
-            pub fn latency(&mut self) -> _LATENCYW {
-                _LATENCYW { w: self }
-            }
-            #[doc = "Bit 8 - Prefetch enable"]
-            #[inline]
-            pub fn prften(&mut self) -> _PRFTENW {
-                _PRFTENW { w: self }
-            }
-            #[doc = "Bit 9 - Instruction cache enable"]
-            #[inline]
-            pub fn icen(&mut self) -> _ICENW {
-                _ICENW { w: self }
-            }
-            #[doc = "Bit 10 - Data cache enable"]
-            #[inline]
-            pub fn dcen(&mut self) -> _DCENW {
-                _DCENW { w: self }
-            }
-            #[doc = "Bit 11 - Instruction cache reset"]
-            #[inline]
-            pub fn icrst(&mut self) -> _ICRSTW {
-                _ICRSTW { w: self }
-            }
-            #[doc = "Bit 12 - Data cache reset"]
-            #[inline]
-            pub fn dcrst(&mut self) -> _DCRSTW {
-                _DCRSTW { w: self }
-            }
-        }
-    }
-    #[doc = "Flash key register"]
-    pub struct KEYR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Flash key register"]
-    pub mod keyr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::KEYR {
-            #[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" Proxy"]
-        pub struct _KEYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _KEYW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        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 0:31 - FPEC key"]
-            #[inline]
-            pub fn key(&mut self) -> _KEYW {
-                _KEYW { w: self }
-            }
-        }
-    }
-    #[doc = "Flash option key register"]
-    pub struct OPTKEYR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Flash option key register"]
-    pub mod optkeyr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::OPTKEYR {
-            #[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" Proxy"]
-        pub struct _OPTKEYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPTKEYW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        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 0:31 - Option byte key"]
-            #[inline]
-            pub fn optkey(&mut self) -> _OPTKEYW {
-                _OPTKEYW { w: self }
-            }
-        }
-    }
-    #[doc = "Status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct EOPR {
-            bits: bool,
-        }
-        impl EOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPERRR {
-            bits: bool,
-        }
-        impl OPERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WRPERRR {
-            bits: bool,
-        }
-        impl WRPERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PGAERRR {
-            bits: bool,
-        }
-        impl PGAERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PGPERRR {
-            bits: bool,
-        }
-        impl PGPERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PGSERRR {
-            bits: bool,
-        }
-        impl PGSERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BSYR {
-            bits: bool,
-        }
-        impl BSYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _EOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WRPERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WRPERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PGAERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PGAERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PGPERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PGPERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PGSERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PGSERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - End of operation"]
-            #[inline]
-            pub fn eop(&self) -> EOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EOPR { bits }
-            }
-            #[doc = "Bit 1 - Operation error"]
-            #[inline]
-            pub fn operr(&self) -> OPERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPERRR { bits }
-            }
-            #[doc = "Bit 4 - Write protection error"]
-            #[inline]
-            pub fn wrperr(&self) -> WRPERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRPERRR { bits }
-            }
-            #[doc = "Bit 5 - Programming alignment error"]
-            #[inline]
-            pub fn pgaerr(&self) -> PGAERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PGAERRR { bits }
-            }
-            #[doc = "Bit 6 - Programming parallelism error"]
-            #[inline]
-            pub fn pgperr(&self) -> PGPERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PGPERRR { bits }
-            }
-            #[doc = "Bit 7 - Programming sequence error"]
-            #[inline]
-            pub fn pgserr(&self) -> PGSERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PGSERRR { bits }
-            }
-            #[doc = "Bit 16 - Busy"]
-            #[inline]
-            pub fn bsy(&self) -> BSYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BSYR { bits }
-            }
-        }
-        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 - End of operation"]
-            #[inline]
-            pub fn eop(&mut self) -> _EOPW {
-                _EOPW { w: self }
-            }
-            #[doc = "Bit 1 - Operation error"]
-            #[inline]
-            pub fn operr(&mut self) -> _OPERRW {
-                _OPERRW { w: self }
-            }
-            #[doc = "Bit 4 - Write protection error"]
-            #[inline]
-            pub fn wrperr(&mut self) -> _WRPERRW {
-                _WRPERRW { w: self }
-            }
-            #[doc = "Bit 5 - Programming alignment error"]
-            #[inline]
-            pub fn pgaerr(&mut self) -> _PGAERRW {
-                _PGAERRW { w: self }
-            }
-            #[doc = "Bit 6 - Programming parallelism error"]
-            #[inline]
-            pub fn pgperr(&mut self) -> _PGPERRW {
-                _PGPERRW { w: self }
-            }
-            #[doc = "Bit 7 - Programming sequence error"]
-            #[inline]
-            pub fn pgserr(&mut self) -> _PGSERRW {
-                _PGSERRW { w: self }
-            }
-        }
-    }
-    #[doc = "Control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct PGR {
-            bits: bool,
-        }
-        impl PGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SERR {
-            bits: bool,
-        }
-        impl SERR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MERR {
-            bits: bool,
-        }
-        impl MERR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SNBR {
-            bits: u8,
-        }
-        impl SNBR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STRTR {
-            bits: bool,
-        }
-        impl STRTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EOPIER {
-            bits: bool,
-        }
-        impl EOPIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ERRIER {
-            bits: bool,
-        }
-        impl ERRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LOCKR {
-            bits: bool,
-        }
-        impl LOCKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _PGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SERW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SERW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MERW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MERW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNBW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNBW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _STRTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STRTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EOPIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EOPIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ERRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ERRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LOCKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LOCKW<'a> {
-            #[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 - Programming"]
-            #[inline]
-            pub fn pg(&self) -> PGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PGR { bits }
-            }
-            #[doc = "Bit 1 - Sector Erase"]
-            #[inline]
-            pub fn ser(&self) -> SERR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SERR { bits }
-            }
-            #[doc = "Bit 2 - Mass Erase"]
-            #[inline]
-            pub fn mer(&self) -> MERR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MERR { bits }
-            }
-            #[doc = "Bits 3:6 - Sector number"]
-            #[inline]
-            pub fn snb(&self) -> SNBR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SNBR { bits }
-            }
-            #[doc = "Bits 8:9 - Program size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 16 - Start"]
-            #[inline]
-            pub fn strt(&self) -> STRTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STRTR { bits }
-            }
-            #[doc = "Bit 24 - End of operation interrupt enable"]
-            #[inline]
-            pub fn eopie(&self) -> EOPIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EOPIER { bits }
-            }
-            #[doc = "Bit 25 - Error interrupt enable"]
-            #[inline]
-            pub fn errie(&self) -> ERRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ERRIER { bits }
-            }
-            #[doc = "Bit 31 - Lock"]
-            #[inline]
-            pub fn lock(&self) -> LOCKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LOCKR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x8000_0000 }
-            }
-            #[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 - Programming"]
-            #[inline]
-            pub fn pg(&mut self) -> _PGW {
-                _PGW { w: self }
-            }
-            #[doc = "Bit 1 - Sector Erase"]
-            #[inline]
-            pub fn ser(&mut self) -> _SERW {
-                _SERW { w: self }
-            }
-            #[doc = "Bit 2 - Mass Erase"]
-            #[inline]
-            pub fn mer(&mut self) -> _MERW {
-                _MERW { w: self }
-            }
-            #[doc = "Bits 3:6 - Sector number"]
-            #[inline]
-            pub fn snb(&mut self) -> _SNBW {
-                _SNBW { w: self }
-            }
-            #[doc = "Bits 8:9 - Program size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 16 - Start"]
-            #[inline]
-            pub fn strt(&mut self) -> _STRTW {
-                _STRTW { w: self }
-            }
-            #[doc = "Bit 24 - End of operation interrupt enable"]
-            #[inline]
-            pub fn eopie(&mut self) -> _EOPIEW {
-                _EOPIEW { w: self }
-            }
-            #[doc = "Bit 25 - Error interrupt enable"]
-            #[inline]
-            pub fn errie(&mut self) -> _ERRIEW {
-                _ERRIEW { w: self }
-            }
-            #[doc = "Bit 31 - Lock"]
-            #[inline]
-            pub fn lock(&mut self) -> _LOCKW {
-                _LOCKW { w: self }
-            }
-        }
-    }
-    #[doc = "Flash option control register"]
-    pub struct OPTCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Flash option control register"]
-    pub mod optcr {
-        #[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::OPTCR {
-            #[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 = r" Value of the field"]
-        pub struct OPTLOCKR {
-            bits: bool,
-        }
-        impl OPTLOCKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPTSTRTR {
-            bits: bool,
-        }
-        impl OPTSTRTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BOR_LEVR {
-            bits: u8,
-        }
-        impl BOR_LEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct WDG_SWR {
-            bits: bool,
-        }
-        impl WDG_SWR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NRST_STOPR {
-            bits: bool,
-        }
-        impl NRST_STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NRST_STDBYR {
-            bits: bool,
-        }
-        impl NRST_STDBYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RDPR {
-            bits: u8,
-        }
-        impl RDPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NWRPR {
-            bits: u16,
-        }
-        impl NWRPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OPTLOCKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPTLOCKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPTSTRTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPTSTRTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BOR_LEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BOR_LEVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDG_SWW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDG_SWW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NRST_STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NRST_STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NRST_STDBYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NRST_STDBYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RDPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RDPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NWRPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NWRPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 16;
-                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 - Option lock"]
-            #[inline]
-            pub fn optlock(&self) -> OPTLOCKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPTLOCKR { bits }
-            }
-            #[doc = "Bit 1 - Option start"]
-            #[inline]
-            pub fn optstrt(&self) -> OPTSTRTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPTSTRTR { bits }
-            }
-            #[doc = "Bits 2:3 - BOR reset Level"]
-            #[inline]
-            pub fn bor_lev(&self) -> BOR_LEVR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BOR_LEVR { bits }
-            }
-            #[doc = "Bit 5 - WDG_SW User option bytes"]
-            #[inline]
-            pub fn wdg_sw(&self) -> WDG_SWR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WDG_SWR { bits }
-            }
-            #[doc = "Bit 6 - nRST_STOP User option bytes"]
-            #[inline]
-            pub fn n_rst_stop(&self) -> NRST_STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NRST_STOPR { bits }
-            }
-            #[doc = "Bit 7 - nRST_STDBY User option bytes"]
-            #[inline]
-            pub fn n_rst_stdby(&self) -> NRST_STDBYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NRST_STDBYR { bits }
-            }
-            #[doc = "Bits 8:15 - Read protect"]
-            #[inline]
-            pub fn rdp(&self) -> RDPR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RDPR { bits }
-            }
-            #[doc = "Bits 16:27 - Not write protect"]
-            #[inline]
-            pub fn n_wrp(&self) -> NWRPR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NWRPR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x14 }
-            }
-            #[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 - Option lock"]
-            #[inline]
-            pub fn optlock(&mut self) -> _OPTLOCKW {
-                _OPTLOCKW { w: self }
-            }
-            #[doc = "Bit 1 - Option start"]
-            #[inline]
-            pub fn optstrt(&mut self) -> _OPTSTRTW {
-                _OPTSTRTW { w: self }
-            }
-            #[doc = "Bits 2:3 - BOR reset Level"]
-            #[inline]
-            pub fn bor_lev(&mut self) -> _BOR_LEVW {
-                _BOR_LEVW { w: self }
-            }
-            #[doc = "Bit 5 - WDG_SW User option bytes"]
-            #[inline]
-            pub fn wdg_sw(&mut self) -> _WDG_SWW {
-                _WDG_SWW { w: self }
-            }
-            #[doc = "Bit 6 - nRST_STOP User option bytes"]
-            #[inline]
-            pub fn n_rst_stop(&mut self) -> _NRST_STOPW {
-                _NRST_STOPW { w: self }
-            }
-            #[doc = "Bit 7 - nRST_STDBY User option bytes"]
-            #[inline]
-            pub fn n_rst_stdby(&mut self) -> _NRST_STDBYW {
-                _NRST_STDBYW { w: self }
-            }
-            #[doc = "Bits 8:15 - Read protect"]
-            #[inline]
-            pub fn rdp(&mut self) -> _RDPW {
-                _RDPW { w: self }
-            }
-            #[doc = "Bits 16:27 - Not write protect"]
-            #[inline]
-            pub fn n_wrp(&mut self) -> _NWRPW {
-                _NWRPW { w: self }
-            }
-        }
-    }
-}
-#[doc = "Independent watchdog"]
-pub struct IWDG {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for IWDG {}
-impl IWDG {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const iwdg::RegisterBlock {
-        0x4000_3000 as *const _
-    }
-}
-impl Deref for IWDG {
-    type Target = iwdg::RegisterBlock;
-    fn deref(&self) -> &iwdg::RegisterBlock {
-        unsafe { &*IWDG::ptr() }
-    }
-}
-#[doc = "Independent watchdog"]
-pub mod iwdg {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Key register"]
-        pub kr: KR,
-        #[doc = "0x04 - Prescaler register"]
-        pub pr: PR,
-        #[doc = "0x08 - Reload register"]
-        pub rlr: RLR,
-        #[doc = "0x0c - Status register"]
-        pub sr: SR,
-    }
-    #[doc = "Key register"]
-    pub struct KR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Key register"]
-    pub mod kr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::KR {
-            #[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" Proxy"]
-        pub struct _KEYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _KEYW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        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 0:15 - Key value"]
-            #[inline]
-            pub fn key(&mut self) -> _KEYW {
-                _KEYW { w: self }
-            }
-        }
-    }
-    #[doc = "Prescaler register"]
-    pub struct PR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Prescaler register"]
-    pub mod pr {
-        #[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::PR {
-            #[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 = r" Value of the field"]
-        pub struct PRR {
-            bits: u8,
-        }
-        impl PRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 0:2 - Prescaler divider"]
-            #[inline]
-            pub fn pr(&self) -> PRR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PRR { bits }
-            }
-        }
-        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 0:2 - Prescaler divider"]
-            #[inline]
-            pub fn pr(&mut self) -> _PRW {
-                _PRW { w: self }
-            }
-        }
-    }
-    #[doc = "Reload register"]
-    pub struct RLR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Reload register"]
-    pub mod rlr {
-        #[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::RLR {
-            #[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 = r" Value of the field"]
-        pub struct RLR {
-            bits: u16,
-        }
-        impl RLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - Watchdog counter reload value"]
-            #[inline]
-            pub fn rl(&self) -> RLR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                RLR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0fff }
-            }
-            #[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 0:11 - Watchdog counter reload value"]
-            #[inline]
-            pub fn rl(&mut self) -> _RLW {
-                _RLW { w: self }
-            }
-        }
-    }
-    #[doc = "Status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Status register"]
-    pub mod sr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::SR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RVUR {
-            bits: bool,
-        }
-        impl RVUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PVUR {
-            bits: bool,
-        }
-        impl PVUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 1 - Watchdog counter reload value update"]
-            #[inline]
-            pub fn rvu(&self) -> RVUR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RVUR { bits }
-            }
-            #[doc = "Bit 0 - Watchdog prescaler value update"]
-            #[inline]
-            pub fn pvu(&self) -> PVUR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PVUR { bits }
-            }
-        }
-    }
-}
-#[doc = "Power control"]
-pub struct PWR {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for PWR {}
-impl PWR {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const pwr::RegisterBlock {
-        0x4000_7000 as *const _
-    }
-}
-impl Deref for PWR {
-    type Target = pwr::RegisterBlock;
-    fn deref(&self) -> &pwr::RegisterBlock {
-        unsafe { &*PWR::ptr() }
-    }
-}
-#[doc = "Power control"]
-pub mod pwr {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - power control register"]
-        pub cr: CR,
-        #[doc = "0x04 - power control/status register"]
-        pub csr: CSR,
-    }
-    #[doc = "power control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "power control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct VOSR {
-            bits: u8,
-        }
-        impl VOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADCDC1R {
-            bits: bool,
-        }
-        impl ADCDC1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FPDSR {
-            bits: bool,
-        }
-        impl FPDSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBPR {
-            bits: bool,
-        }
-        impl DBPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLSR {
-            bits: u8,
-        }
-        impl PLSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PVDER {
-            bits: bool,
-        }
-        impl PVDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CSBFR {
-            bits: bool,
-        }
-        impl CSBFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CWUFR {
-            bits: bool,
-        }
-        impl CWUFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PDDSR {
-            bits: bool,
-        }
-        impl PDDSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LPDSR {
-            bits: bool,
-        }
-        impl LPDSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _VOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _VOSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADCDC1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADCDC1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FPDSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FPDSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PVDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PVDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CSBFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CSBFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CWUFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CWUFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PDDSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PDDSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LPDSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LPDSW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 14:15 - Regulator voltage scaling output selection"]
-            #[inline]
-            pub fn vos(&self) -> VOSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                VOSR { bits }
-            }
-            #[doc = "Bit 13 - ADCDC1"]
-            #[inline]
-            pub fn adcdc1(&self) -> ADCDC1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADCDC1R { bits }
-            }
-            #[doc = "Bit 9 - Flash power down in Stop mode"]
-            #[inline]
-            pub fn fpds(&self) -> FPDSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FPDSR { bits }
-            }
-            #[doc = "Bit 8 - Disable backup domain write protection"]
-            #[inline]
-            pub fn dbp(&self) -> DBPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBPR { bits }
-            }
-            #[doc = "Bits 5:7 - PVD level selection"]
-            #[inline]
-            pub fn pls(&self) -> PLSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLSR { bits }
-            }
-            #[doc = "Bit 4 - Power voltage detector enable"]
-            #[inline]
-            pub fn pvde(&self) -> PVDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PVDER { bits }
-            }
-            #[doc = "Bit 3 - Clear standby flag"]
-            #[inline]
-            pub fn csbf(&self) -> CSBFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CSBFR { bits }
-            }
-            #[doc = "Bit 2 - Clear wakeup flag"]
-            #[inline]
-            pub fn cwuf(&self) -> CWUFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CWUFR { bits }
-            }
-            #[doc = "Bit 1 - Power down deepsleep"]
-            #[inline]
-            pub fn pdds(&self) -> PDDSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PDDSR { bits }
-            }
-            #[doc = "Bit 0 - Low-power deep sleep"]
-            #[inline]
-            pub fn lpds(&self) -> LPDSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LPDSR { bits }
-            }
-        }
-        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 14:15 - Regulator voltage scaling output selection"]
-            #[inline]
-            pub fn vos(&mut self) -> _VOSW {
-                _VOSW { w: self }
-            }
-            #[doc = "Bit 13 - ADCDC1"]
-            #[inline]
-            pub fn adcdc1(&mut self) -> _ADCDC1W {
-                _ADCDC1W { w: self }
-            }
-            #[doc = "Bit 9 - Flash power down in Stop mode"]
-            #[inline]
-            pub fn fpds(&mut self) -> _FPDSW {
-                _FPDSW { w: self }
-            }
-            #[doc = "Bit 8 - Disable backup domain write protection"]
-            #[inline]
-            pub fn dbp(&mut self) -> _DBPW {
-                _DBPW { w: self }
-            }
-            #[doc = "Bits 5:7 - PVD level selection"]
-            #[inline]
-            pub fn pls(&mut self) -> _PLSW {
-                _PLSW { w: self }
-            }
-            #[doc = "Bit 4 - Power voltage detector enable"]
-            #[inline]
-            pub fn pvde(&mut self) -> _PVDEW {
-                _PVDEW { w: self }
-            }
-            #[doc = "Bit 3 - Clear standby flag"]
-            #[inline]
-            pub fn csbf(&mut self) -> _CSBFW {
-                _CSBFW { w: self }
-            }
-            #[doc = "Bit 2 - Clear wakeup flag"]
-            #[inline]
-            pub fn cwuf(&mut self) -> _CWUFW {
-                _CWUFW { w: self }
-            }
-            #[doc = "Bit 1 - Power down deepsleep"]
-            #[inline]
-            pub fn pdds(&mut self) -> _PDDSW {
-                _PDDSW { w: self }
-            }
-            #[doc = "Bit 0 - Low-power deep sleep"]
-            #[inline]
-            pub fn lpds(&mut self) -> _LPDSW {
-                _LPDSW { w: self }
-            }
-        }
-    }
-    #[doc = "power control/status register"]
-    pub struct CSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "power control/status register"]
-    pub mod csr {
-        #[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::CSR {
-            #[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 = r" Value of the field"]
-        pub struct WUFR {
-            bits: bool,
-        }
-        impl WUFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SBFR {
-            bits: bool,
-        }
-        impl SBFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PVDOR {
-            bits: bool,
-        }
-        impl PVDOR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BRRR {
-            bits: bool,
-        }
-        impl BRRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EWUPR {
-            bits: bool,
-        }
-        impl EWUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BRER {
-            bits: bool,
-        }
-        impl BRER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct VOSRDYR {
-            bits: bool,
-        }
-        impl VOSRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _EWUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EWUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BREW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BREW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _VOSRDYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _VOSRDYW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Wakeup flag"]
-            #[inline]
-            pub fn wuf(&self) -> WUFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WUFR { bits }
-            }
-            #[doc = "Bit 1 - Standby flag"]
-            #[inline]
-            pub fn sbf(&self) -> SBFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SBFR { bits }
-            }
-            #[doc = "Bit 2 - PVD output"]
-            #[inline]
-            pub fn pvdo(&self) -> PVDOR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PVDOR { bits }
-            }
-            #[doc = "Bit 3 - Backup regulator ready"]
-            #[inline]
-            pub fn brr(&self) -> BRRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BRRR { bits }
-            }
-            #[doc = "Bit 8 - Enable WKUP pin"]
-            #[inline]
-            pub fn ewup(&self) -> EWUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EWUPR { bits }
-            }
-            #[doc = "Bit 9 - Backup regulator enable"]
-            #[inline]
-            pub fn bre(&self) -> BRER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BRER { bits }
-            }
-            #[doc = "Bit 14 - Regulator voltage scaling output selection ready bit"]
-            #[inline]
-            pub fn vosrdy(&self) -> VOSRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                VOSRDYR { bits }
-            }
-        }
-        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 8 - Enable WKUP pin"]
-            #[inline]
-            pub fn ewup(&mut self) -> _EWUPW {
-                _EWUPW { w: self }
-            }
-            #[doc = "Bit 9 - Backup regulator enable"]
-            #[inline]
-            pub fn bre(&mut self) -> _BREW {
-                _BREW { w: self }
-            }
-            #[doc = "Bit 14 - Regulator voltage scaling output selection ready bit"]
-            #[inline]
-            pub fn vosrdy(&mut self) -> _VOSRDYW {
-                _VOSRDYW { w: self }
-            }
-        }
-    }
-}
-#[doc = "Reset and clock control"]
-pub struct RCC {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for RCC {}
-impl RCC {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const rcc::RegisterBlock {
-        0x4002_3800 as *const _
-    }
-}
-impl Deref for RCC {
-    type Target = rcc::RegisterBlock;
-    fn deref(&self) -> &rcc::RegisterBlock {
-        unsafe { &*RCC::ptr() }
-    }
-}
-#[doc = "Reset and clock control"]
-pub mod rcc {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - clock control register"]
-        pub cr: CR,
-        #[doc = "0x04 - PLL configuration register"]
-        pub pllcfgr: PLLCFGR,
-        #[doc = "0x08 - clock configuration register"]
-        pub cfgr: CFGR,
-        #[doc = "0x0c - clock interrupt register"]
-        pub cir: CIR,
-        #[doc = "0x10 - AHB1 peripheral reset register"]
-        pub ahb1rstr: AHB1RSTR,
-        #[doc = "0x14 - AHB2 peripheral reset register"]
-        pub ahb2rstr: AHB2RSTR,
-        #[doc = "0x18 - peripheral reset register"]
-        pub ahb3rstr: AHB3RSTR,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x20 - APB1 peripheral reset register"]
-        pub apb1rstr: APB1RSTR,
-        #[doc = "0x24 - APB2 peripheral reset register"]
-        pub apb2rstr: APB2RSTR,
-        _reserved1: [u8; 8usize],
-        #[doc = "0x30 - AHB1 peripheral clock register"]
-        pub ahb1enr: AHB1ENR,
-        #[doc = "0x34 - AHB2 peripheral clock enable register"]
-        pub ahb2enr: AHB2ENR,
-        #[doc = "0x38 - AHB3 peripheral clock enable register"]
-        pub ahb3enr: AHB3ENR,
-        _reserved2: [u8; 4usize],
-        #[doc = "0x40 - APB1 peripheral clock enable register"]
-        pub apb1enr: APB1ENR,
-        #[doc = "0x44 - APB2 peripheral clock enable register"]
-        pub apb2enr: APB2ENR,
-        _reserved3: [u8; 8usize],
-        #[doc = "0x50 - AHB1 peripheral clock enable in low power mode register"]
-        pub ahb1lpenr: AHB1LPENR,
-        #[doc = "0x54 - AHB2 peripheral clock enable in low power mode register"]
-        pub ahb2lpenr: AHB2LPENR,
-        #[doc = "0x58 - AHB3 peripheral clock enable in low power mode register"]
-        pub ahb3lpenr: AHB3LPENR,
-        _reserved4: [u8; 4usize],
-        #[doc = "0x60 - APB1 peripheral clock enable in low power mode register"]
-        pub apb1lpenr: APB1LPENR,
-        #[doc = "0x64 - APB2 peripheral clock enabled in low power mode register"]
-        pub apb2lpenr: APB2LPENR,
-        _reserved5: [u8; 8usize],
-        #[doc = "0x70 - Backup domain control register"]
-        pub bdcr: BDCR,
-        #[doc = "0x74 - clock control & status register"]
-        pub csr: CSR,
-        _reserved6: [u8; 8usize],
-        #[doc = "0x80 - spread spectrum clock generation register"]
-        pub sscgr: SSCGR,
-        #[doc = "0x84 - PLLI2S configuration register"]
-        pub plli2scfgr: PLLI2SCFGR,
-        _reserved7: [u8; 4usize],
-        #[doc = "0x8c - Dedicated Clocks Configuration Register"]
-        pub dckcfgr: DCKCFGR,
-        #[doc = "0x90 - RCC clocks gated enable register"]
-        pub ckgatenr: CKGATENR,
-        #[doc = "0x94 - Dedicated Clocks Configuration Register"]
-        pub dckcfgr2: DCKCFGR2,
-    }
-    #[doc = "clock control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "clock control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct HSIONR {
-            bits: bool,
-        }
-        impl HSIONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSIRDYR {
-            bits: bool,
-        }
-        impl HSIRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSITRIMR {
-            bits: u8,
-        }
-        impl HSITRIMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct HSICALR {
-            bits: u8,
-        }
-        impl HSICALR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct HSEONR {
-            bits: bool,
-        }
-        impl HSEONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSERDYR {
-            bits: bool,
-        }
-        impl HSERDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSEBYPR {
-            bits: bool,
-        }
-        impl HSEBYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CSSONR {
-            bits: bool,
-        }
-        impl CSSONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLONR {
-            bits: bool,
-        }
-        impl PLLONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLRDYR {
-            bits: bool,
-        }
-        impl PLLRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLI2SONR {
-            bits: bool,
-        }
-        impl PLLI2SONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLI2SRDYR {
-            bits: bool,
-        }
-        impl PLLI2SRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _HSIONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSIONW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSIRDYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSIRDYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSITRIMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSITRIMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HSICALW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSICALW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HSEONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSEONW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSERDYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSERDYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSEBYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSEBYPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CSSONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CSSONW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLONW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLRDYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLRDYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLI2SONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SONW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLI2SRDYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SRDYW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Internal high-speed clock enable"]
-            #[inline]
-            pub fn hsion(&self) -> HSIONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSIONR { bits }
-            }
-            #[doc = "Bit 1 - Internal high-speed clock ready flag"]
-            #[inline]
-            pub fn hsirdy(&self) -> HSIRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSIRDYR { bits }
-            }
-            #[doc = "Bits 3:7 - Internal high-speed clock trimming"]
-            #[inline]
-            pub fn hsitrim(&self) -> HSITRIMR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HSITRIMR { bits }
-            }
-            #[doc = "Bits 8:15 - Internal high-speed clock calibration"]
-            #[inline]
-            pub fn hsical(&self) -> HSICALR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HSICALR { bits }
-            }
-            #[doc = "Bit 16 - HSE clock enable"]
-            #[inline]
-            pub fn hseon(&self) -> HSEONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSEONR { bits }
-            }
-            #[doc = "Bit 17 - HSE clock ready flag"]
-            #[inline]
-            pub fn hserdy(&self) -> HSERDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSERDYR { bits }
-            }
-            #[doc = "Bit 18 - HSE clock bypass"]
-            #[inline]
-            pub fn hsebyp(&self) -> HSEBYPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSEBYPR { bits }
-            }
-            #[doc = "Bit 19 - Clock security system enable"]
-            #[inline]
-            pub fn csson(&self) -> CSSONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CSSONR { bits }
-            }
-            #[doc = "Bit 24 - Main PLL (PLL) enable"]
-            #[inline]
-            pub fn pllon(&self) -> PLLONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLONR { bits }
-            }
-            #[doc = "Bit 25 - Main PLL (PLL) clock ready flag"]
-            #[inline]
-            pub fn pllrdy(&self) -> PLLRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLRDYR { bits }
-            }
-            #[doc = "Bit 26 - PLLI2S enable"]
-            #[inline]
-            pub fn plli2son(&self) -> PLLI2SONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLI2SONR { bits }
-            }
-            #[doc = "Bit 27 - PLLI2S clock ready flag"]
-            #[inline]
-            pub fn plli2srdy(&self) -> PLLI2SRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLI2SRDYR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x83 }
-            }
-            #[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 - Internal high-speed clock enable"]
-            #[inline]
-            pub fn hsion(&mut self) -> _HSIONW {
-                _HSIONW { w: self }
-            }
-            #[doc = "Bit 1 - Internal high-speed clock ready flag"]
-            #[inline]
-            pub fn hsirdy(&mut self) -> _HSIRDYW {
-                _HSIRDYW { w: self }
-            }
-            #[doc = "Bits 3:7 - Internal high-speed clock trimming"]
-            #[inline]
-            pub fn hsitrim(&mut self) -> _HSITRIMW {
-                _HSITRIMW { w: self }
-            }
-            #[doc = "Bits 8:15 - Internal high-speed clock calibration"]
-            #[inline]
-            pub fn hsical(&mut self) -> _HSICALW {
-                _HSICALW { w: self }
-            }
-            #[doc = "Bit 16 - HSE clock enable"]
-            #[inline]
-            pub fn hseon(&mut self) -> _HSEONW {
-                _HSEONW { w: self }
-            }
-            #[doc = "Bit 17 - HSE clock ready flag"]
-            #[inline]
-            pub fn hserdy(&mut self) -> _HSERDYW {
-                _HSERDYW { w: self }
-            }
-            #[doc = "Bit 18 - HSE clock bypass"]
-            #[inline]
-            pub fn hsebyp(&mut self) -> _HSEBYPW {
-                _HSEBYPW { w: self }
-            }
-            #[doc = "Bit 19 - Clock security system enable"]
-            #[inline]
-            pub fn csson(&mut self) -> _CSSONW {
-                _CSSONW { w: self }
-            }
-            #[doc = "Bit 24 - Main PLL (PLL) enable"]
-            #[inline]
-            pub fn pllon(&mut self) -> _PLLONW {
-                _PLLONW { w: self }
-            }
-            #[doc = "Bit 25 - Main PLL (PLL) clock ready flag"]
-            #[inline]
-            pub fn pllrdy(&mut self) -> _PLLRDYW {
-                _PLLRDYW { w: self }
-            }
-            #[doc = "Bit 26 - PLLI2S enable"]
-            #[inline]
-            pub fn plli2son(&mut self) -> _PLLI2SONW {
-                _PLLI2SONW { w: self }
-            }
-            #[doc = "Bit 27 - PLLI2S clock ready flag"]
-            #[inline]
-            pub fn plli2srdy(&mut self) -> _PLLI2SRDYW {
-                _PLLI2SRDYW { w: self }
-            }
-        }
-    }
-    #[doc = "PLL configuration register"]
-    pub struct PLLCFGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "PLL configuration register"]
-    pub mod pllcfgr {
-        #[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::PLLCFGR {
-            #[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 = r" Value of the field"]
-        pub struct PLLQ3R {
-            bits: bool,
-        }
-        impl PLLQ3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLQ2R {
-            bits: bool,
-        }
-        impl PLLQ2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLQ1R {
-            bits: bool,
-        }
-        impl PLLQ1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLQ0R {
-            bits: bool,
-        }
-        impl PLLQ0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLSRCR {
-            bits: bool,
-        }
-        impl PLLSRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLP1R {
-            bits: bool,
-        }
-        impl PLLP1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLP0R {
-            bits: bool,
-        }
-        impl PLLP0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN8R {
-            bits: bool,
-        }
-        impl PLLN8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN7R {
-            bits: bool,
-        }
-        impl PLLN7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN6R {
-            bits: bool,
-        }
-        impl PLLN6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN5R {
-            bits: bool,
-        }
-        impl PLLN5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN4R {
-            bits: bool,
-        }
-        impl PLLN4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN3R {
-            bits: bool,
-        }
-        impl PLLN3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN2R {
-            bits: bool,
-        }
-        impl PLLN2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN1R {
-            bits: bool,
-        }
-        impl PLLN1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLN0R {
-            bits: bool,
-        }
-        impl PLLN0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLM5R {
-            bits: bool,
-        }
-        impl PLLM5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLM4R {
-            bits: bool,
-        }
-        impl PLLM4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLM3R {
-            bits: bool,
-        }
-        impl PLLM3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLM2R {
-            bits: bool,
-        }
-        impl PLLM2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLM1R {
-            bits: bool,
-        }
-        impl PLLM1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLM0R {
-            bits: bool,
-        }
-        impl PLLM0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLRR {
-            bits: u8,
-        }
-        impl PLLRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PLLQ3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLQ3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLQ2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLQ2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLQ1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLQ1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLQ0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLQ0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLSRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLSRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLP1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLP1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLP0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLP0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLN0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLN0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLM5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLM5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLM4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLM4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLM3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLM3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLM2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLM2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLM1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLM1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLM0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLM0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 28;
-                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 27 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks" ] # [ inline ]
-            pub fn pllq3(&self) -> PLLQ3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLQ3R { bits }
-            }
-            # [ doc = "Bit 26 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks" ] # [ inline ]
-            pub fn pllq2(&self) -> PLLQ2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLQ2R { bits }
-            }
-            # [ doc = "Bit 25 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks" ] # [ inline ]
-            pub fn pllq1(&self) -> PLLQ1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLQ1R { bits }
-            }
-            # [ doc = "Bit 24 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks" ] # [ inline ]
-            pub fn pllq0(&self) -> PLLQ0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLQ0R { bits }
-            }
-            #[doc = "Bit 22 - Main PLL(PLL) and audio PLL (PLLI2S) entry clock source"]
-            #[inline]
-            pub fn pllsrc(&self) -> PLLSRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLSRCR { bits }
-            }
-            #[doc = "Bit 17 - Main PLL (PLL) division factor for main system clock"]
-            #[inline]
-            pub fn pllp1(&self) -> PLLP1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLP1R { bits }
-            }
-            #[doc = "Bit 16 - Main PLL (PLL) division factor for main system clock"]
-            #[inline]
-            pub fn pllp0(&self) -> PLLP0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLP0R { bits }
-            }
-            #[doc = "Bit 14 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln8(&self) -> PLLN8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN8R { bits }
-            }
-            #[doc = "Bit 13 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln7(&self) -> PLLN7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN7R { bits }
-            }
-            #[doc = "Bit 12 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln6(&self) -> PLLN6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN6R { bits }
-            }
-            #[doc = "Bit 11 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln5(&self) -> PLLN5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN5R { bits }
-            }
-            #[doc = "Bit 10 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln4(&self) -> PLLN4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN4R { bits }
-            }
-            #[doc = "Bit 9 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln3(&self) -> PLLN3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN3R { bits }
-            }
-            #[doc = "Bit 8 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln2(&self) -> PLLN2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN2R { bits }
-            }
-            #[doc = "Bit 7 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln1(&self) -> PLLN1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN1R { bits }
-            }
-            #[doc = "Bit 6 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln0(&self) -> PLLN0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLN0R { bits }
-            }
-            # [ doc = "Bit 5 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm5(&self) -> PLLM5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLM5R { bits }
-            }
-            # [ doc = "Bit 4 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm4(&self) -> PLLM4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLM4R { bits }
-            }
-            # [ doc = "Bit 3 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm3(&self) -> PLLM3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLM3R { bits }
-            }
-            # [ doc = "Bit 2 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm2(&self) -> PLLM2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLM2R { bits }
-            }
-            # [ doc = "Bit 1 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm1(&self) -> PLLM1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLM1R { bits }
-            }
-            # [ doc = "Bit 0 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm0(&self) -> PLLM0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLM0R { bits }
-            }
-            #[doc = "Bits 28:30 - Main PLL (PLL) division factor for I2S, DFSDM clocks"]
-            #[inline]
-            pub fn pllr(&self) -> PLLRR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLLRR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x2400_3010 }
-            }
-            #[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 27 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks" ] # [ inline ]
-            pub fn pllq3(&mut self) -> _PLLQ3W {
-                _PLLQ3W { w: self }
-            }
-            # [ doc = "Bit 26 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks" ] # [ inline ]
-            pub fn pllq2(&mut self) -> _PLLQ2W {
-                _PLLQ2W { w: self }
-            }
-            # [ doc = "Bit 25 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks" ] # [ inline ]
-            pub fn pllq1(&mut self) -> _PLLQ1W {
-                _PLLQ1W { w: self }
-            }
-            # [ doc = "Bit 24 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks" ] # [ inline ]
-            pub fn pllq0(&mut self) -> _PLLQ0W {
-                _PLLQ0W { w: self }
-            }
-            #[doc = "Bit 22 - Main PLL(PLL) and audio PLL (PLLI2S) entry clock source"]
-            #[inline]
-            pub fn pllsrc(&mut self) -> _PLLSRCW {
-                _PLLSRCW { w: self }
-            }
-            #[doc = "Bit 17 - Main PLL (PLL) division factor for main system clock"]
-            #[inline]
-            pub fn pllp1(&mut self) -> _PLLP1W {
-                _PLLP1W { w: self }
-            }
-            #[doc = "Bit 16 - Main PLL (PLL) division factor for main system clock"]
-            #[inline]
-            pub fn pllp0(&mut self) -> _PLLP0W {
-                _PLLP0W { w: self }
-            }
-            #[doc = "Bit 14 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln8(&mut self) -> _PLLN8W {
-                _PLLN8W { w: self }
-            }
-            #[doc = "Bit 13 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln7(&mut self) -> _PLLN7W {
-                _PLLN7W { w: self }
-            }
-            #[doc = "Bit 12 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln6(&mut self) -> _PLLN6W {
-                _PLLN6W { w: self }
-            }
-            #[doc = "Bit 11 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln5(&mut self) -> _PLLN5W {
-                _PLLN5W { w: self }
-            }
-            #[doc = "Bit 10 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln4(&mut self) -> _PLLN4W {
-                _PLLN4W { w: self }
-            }
-            #[doc = "Bit 9 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln3(&mut self) -> _PLLN3W {
-                _PLLN3W { w: self }
-            }
-            #[doc = "Bit 8 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln2(&mut self) -> _PLLN2W {
-                _PLLN2W { w: self }
-            }
-            #[doc = "Bit 7 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln1(&mut self) -> _PLLN1W {
-                _PLLN1W { w: self }
-            }
-            #[doc = "Bit 6 - Main PLL (PLL) multiplication factor for VCO"]
-            #[inline]
-            pub fn plln0(&mut self) -> _PLLN0W {
-                _PLLN0W { w: self }
-            }
-            # [ doc = "Bit 5 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm5(&mut self) -> _PLLM5W {
-                _PLLM5W { w: self }
-            }
-            # [ doc = "Bit 4 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm4(&mut self) -> _PLLM4W {
-                _PLLM4W { w: self }
-            }
-            # [ doc = "Bit 3 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm3(&mut self) -> _PLLM3W {
-                _PLLM3W { w: self }
-            }
-            # [ doc = "Bit 2 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm2(&mut self) -> _PLLM2W {
-                _PLLM2W { w: self }
-            }
-            # [ doc = "Bit 1 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm1(&mut self) -> _PLLM1W {
-                _PLLM1W { w: self }
-            }
-            # [ doc = "Bit 0 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn pllm0(&mut self) -> _PLLM0W {
-                _PLLM0W { w: self }
-            }
-            #[doc = "Bits 28:30 - Main PLL (PLL) division factor for I2S, DFSDM clocks"]
-            #[inline]
-            pub fn pllr(&mut self) -> _PLLRW {
-                _PLLRW { w: self }
-            }
-        }
-    }
-    #[doc = "clock configuration register"]
-    pub struct CFGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "clock configuration register"]
-    pub mod cfgr {
-        #[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::CFGR {
-            #[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 = r" Value of the field"]
-        pub struct MCO2R {
-            bits: u8,
-        }
-        impl MCO2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCO2PRER {
-            bits: u8,
-        }
-        impl MCO2PRER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCO1PRER {
-            bits: u8,
-        }
-        impl MCO1PRER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCO1R {
-            bits: u8,
-        }
-        impl MCO1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RTCPRER {
-            bits: u8,
-        }
-        impl RTCPRER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PPRE2R {
-            bits: u8,
-        }
-        impl PPRE2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PPRE1R {
-            bits: u8,
-        }
-        impl PPRE1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct HPRER {
-            bits: u8,
-        }
-        impl HPRER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SWS1R {
-            bits: bool,
-        }
-        impl SWS1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SWS0R {
-            bits: bool,
-        }
-        impl SWS0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SW1R {
-            bits: bool,
-        }
-        impl SW1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SW0R {
-            bits: bool,
-        }
-        impl SW0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MCO2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCO2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCO2PREW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCO2PREW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 27;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCO1PREW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCO1PREW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCO1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCO1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RTCPREW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTCPREW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PPRE2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PPRE2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PPRE1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PPRE1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HPREW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HPREW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SW1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SW1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SW0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SW0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 30:31 - Microcontroller clock output 2"]
-            #[inline]
-            pub fn mco2(&self) -> MCO2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCO2R { bits }
-            }
-            #[doc = "Bits 27:29 - MCO2 prescaler"]
-            #[inline]
-            pub fn mco2pre(&self) -> MCO2PRER {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCO2PRER { bits }
-            }
-            #[doc = "Bits 24:26 - MCO1 prescaler"]
-            #[inline]
-            pub fn mco1pre(&self) -> MCO1PRER {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCO1PRER { bits }
-            }
-            #[doc = "Bits 21:22 - Microcontroller clock output 1"]
-            #[inline]
-            pub fn mco1(&self) -> MCO1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCO1R { bits }
-            }
-            #[doc = "Bits 16:20 - HSE division factor for RTC clock"]
-            #[inline]
-            pub fn rtcpre(&self) -> RTCPRER {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RTCPRER { bits }
-            }
-            #[doc = "Bits 13:15 - APB high-speed prescaler (APB2)"]
-            #[inline]
-            pub fn ppre2(&self) -> PPRE2R {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PPRE2R { bits }
-            }
-            #[doc = "Bits 10:12 - APB Low speed prescaler (APB1)"]
-            #[inline]
-            pub fn ppre1(&self) -> PPRE1R {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PPRE1R { bits }
-            }
-            #[doc = "Bits 4:7 - AHB prescaler"]
-            #[inline]
-            pub fn hpre(&self) -> HPRER {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HPRER { bits }
-            }
-            #[doc = "Bit 3 - System clock switch status"]
-            #[inline]
-            pub fn sws1(&self) -> SWS1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWS1R { bits }
-            }
-            #[doc = "Bit 2 - System clock switch status"]
-            #[inline]
-            pub fn sws0(&self) -> SWS0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWS0R { bits }
-            }
-            #[doc = "Bit 1 - System clock switch"]
-            #[inline]
-            pub fn sw1(&self) -> SW1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SW1R { bits }
-            }
-            #[doc = "Bit 0 - System clock switch"]
-            #[inline]
-            pub fn sw0(&self) -> SW0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SW0R { bits }
-            }
-        }
-        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 30:31 - Microcontroller clock output 2"]
-            #[inline]
-            pub fn mco2(&mut self) -> _MCO2W {
-                _MCO2W { w: self }
-            }
-            #[doc = "Bits 27:29 - MCO2 prescaler"]
-            #[inline]
-            pub fn mco2pre(&mut self) -> _MCO2PREW {
-                _MCO2PREW { w: self }
-            }
-            #[doc = "Bits 24:26 - MCO1 prescaler"]
-            #[inline]
-            pub fn mco1pre(&mut self) -> _MCO1PREW {
-                _MCO1PREW { w: self }
-            }
-            #[doc = "Bits 21:22 - Microcontroller clock output 1"]
-            #[inline]
-            pub fn mco1(&mut self) -> _MCO1W {
-                _MCO1W { w: self }
-            }
-            #[doc = "Bits 16:20 - HSE division factor for RTC clock"]
-            #[inline]
-            pub fn rtcpre(&mut self) -> _RTCPREW {
-                _RTCPREW { w: self }
-            }
-            #[doc = "Bits 13:15 - APB high-speed prescaler (APB2)"]
-            #[inline]
-            pub fn ppre2(&mut self) -> _PPRE2W {
-                _PPRE2W { w: self }
-            }
-            #[doc = "Bits 10:12 - APB Low speed prescaler (APB1)"]
-            #[inline]
-            pub fn ppre1(&mut self) -> _PPRE1W {
-                _PPRE1W { w: self }
-            }
-            #[doc = "Bits 4:7 - AHB prescaler"]
-            #[inline]
-            pub fn hpre(&mut self) -> _HPREW {
-                _HPREW { w: self }
-            }
-            #[doc = "Bit 1 - System clock switch"]
-            #[inline]
-            pub fn sw1(&mut self) -> _SW1W {
-                _SW1W { w: self }
-            }
-            #[doc = "Bit 0 - System clock switch"]
-            #[inline]
-            pub fn sw0(&mut self) -> _SW0W {
-                _SW0W { w: self }
-            }
-        }
-    }
-    #[doc = "clock interrupt register"]
-    pub struct CIR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "clock interrupt register"]
-    pub mod cir {
-        #[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::CIR {
-            #[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 = r" Value of the field"]
-        pub struct PLLI2SRDYIER {
-            bits: bool,
-        }
-        impl PLLI2SRDYIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLRDYIER {
-            bits: bool,
-        }
-        impl PLLRDYIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSERDYIER {
-            bits: bool,
-        }
-        impl HSERDYIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSIRDYIER {
-            bits: bool,
-        }
-        impl HSIRDYIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSERDYIER {
-            bits: bool,
-        }
-        impl LSERDYIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSIRDYIER {
-            bits: bool,
-        }
-        impl LSIRDYIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CSSFR {
-            bits: bool,
-        }
-        impl CSSFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLI2SRDYFR {
-            bits: bool,
-        }
-        impl PLLI2SRDYFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLRDYFR {
-            bits: bool,
-        }
-        impl PLLRDYFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSERDYFR {
-            bits: bool,
-        }
-        impl HSERDYFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSIRDYFR {
-            bits: bool,
-        }
-        impl HSIRDYFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSERDYFR {
-            bits: bool,
-        }
-        impl LSERDYFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSIRDYFR {
-            bits: bool,
-        }
-        impl LSIRDYFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CSSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CSSCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLI2SRDYCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SRDYCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLRDYCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLRDYCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSERDYCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSERDYCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSIRDYCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSIRDYCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSERDYCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSERDYCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSIRDYCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSIRDYCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLI2SRDYIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SRDYIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLRDYIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLRDYIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSERDYIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSERDYIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSIRDYIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSIRDYIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSERDYIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSERDYIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSIRDYIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSIRDYIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 13 - PLLI2S ready interrupt enable"]
-            #[inline]
-            pub fn plli2srdyie(&self) -> PLLI2SRDYIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLI2SRDYIER { bits }
-            }
-            #[doc = "Bit 12 - Main PLL (PLL) ready interrupt enable"]
-            #[inline]
-            pub fn pllrdyie(&self) -> PLLRDYIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLRDYIER { bits }
-            }
-            #[doc = "Bit 11 - HSE ready interrupt enable"]
-            #[inline]
-            pub fn hserdyie(&self) -> HSERDYIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSERDYIER { bits }
-            }
-            #[doc = "Bit 10 - HSI ready interrupt enable"]
-            #[inline]
-            pub fn hsirdyie(&self) -> HSIRDYIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSIRDYIER { bits }
-            }
-            #[doc = "Bit 9 - LSE ready interrupt enable"]
-            #[inline]
-            pub fn lserdyie(&self) -> LSERDYIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSERDYIER { bits }
-            }
-            #[doc = "Bit 8 - LSI ready interrupt enable"]
-            #[inline]
-            pub fn lsirdyie(&self) -> LSIRDYIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSIRDYIER { bits }
-            }
-            #[doc = "Bit 7 - Clock security system interrupt flag"]
-            #[inline]
-            pub fn cssf(&self) -> CSSFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CSSFR { bits }
-            }
-            #[doc = "Bit 5 - PLLI2S ready interrupt flag"]
-            #[inline]
-            pub fn plli2srdyf(&self) -> PLLI2SRDYFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLI2SRDYFR { bits }
-            }
-            #[doc = "Bit 4 - Main PLL (PLL) ready interrupt flag"]
-            #[inline]
-            pub fn pllrdyf(&self) -> PLLRDYFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLRDYFR { bits }
-            }
-            #[doc = "Bit 3 - HSE ready interrupt flag"]
-            #[inline]
-            pub fn hserdyf(&self) -> HSERDYFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSERDYFR { bits }
-            }
-            #[doc = "Bit 2 - HSI ready interrupt flag"]
-            #[inline]
-            pub fn hsirdyf(&self) -> HSIRDYFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSIRDYFR { bits }
-            }
-            #[doc = "Bit 1 - LSE ready interrupt flag"]
-            #[inline]
-            pub fn lserdyf(&self) -> LSERDYFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSERDYFR { bits }
-            }
-            #[doc = "Bit 0 - LSI ready interrupt flag"]
-            #[inline]
-            pub fn lsirdyf(&self) -> LSIRDYFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSIRDYFR { bits }
-            }
-        }
-        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 23 - Clock security system interrupt clear"]
-            #[inline]
-            pub fn cssc(&mut self) -> _CSSCW {
-                _CSSCW { w: self }
-            }
-            #[doc = "Bit 21 - PLLI2S ready interrupt clear"]
-            #[inline]
-            pub fn plli2srdyc(&mut self) -> _PLLI2SRDYCW {
-                _PLLI2SRDYCW { w: self }
-            }
-            #[doc = "Bit 20 - Main PLL(PLL) ready interrupt clear"]
-            #[inline]
-            pub fn pllrdyc(&mut self) -> _PLLRDYCW {
-                _PLLRDYCW { w: self }
-            }
-            #[doc = "Bit 19 - HSE ready interrupt clear"]
-            #[inline]
-            pub fn hserdyc(&mut self) -> _HSERDYCW {
-                _HSERDYCW { w: self }
-            }
-            #[doc = "Bit 18 - HSI ready interrupt clear"]
-            #[inline]
-            pub fn hsirdyc(&mut self) -> _HSIRDYCW {
-                _HSIRDYCW { w: self }
-            }
-            #[doc = "Bit 17 - LSE ready interrupt clear"]
-            #[inline]
-            pub fn lserdyc(&mut self) -> _LSERDYCW {
-                _LSERDYCW { w: self }
-            }
-            #[doc = "Bit 16 - LSI ready interrupt clear"]
-            #[inline]
-            pub fn lsirdyc(&mut self) -> _LSIRDYCW {
-                _LSIRDYCW { w: self }
-            }
-            #[doc = "Bit 13 - PLLI2S ready interrupt enable"]
-            #[inline]
-            pub fn plli2srdyie(&mut self) -> _PLLI2SRDYIEW {
-                _PLLI2SRDYIEW { w: self }
-            }
-            #[doc = "Bit 12 - Main PLL (PLL) ready interrupt enable"]
-            #[inline]
-            pub fn pllrdyie(&mut self) -> _PLLRDYIEW {
-                _PLLRDYIEW { w: self }
-            }
-            #[doc = "Bit 11 - HSE ready interrupt enable"]
-            #[inline]
-            pub fn hserdyie(&mut self) -> _HSERDYIEW {
-                _HSERDYIEW { w: self }
-            }
-            #[doc = "Bit 10 - HSI ready interrupt enable"]
-            #[inline]
-            pub fn hsirdyie(&mut self) -> _HSIRDYIEW {
-                _HSIRDYIEW { w: self }
-            }
-            #[doc = "Bit 9 - LSE ready interrupt enable"]
-            #[inline]
-            pub fn lserdyie(&mut self) -> _LSERDYIEW {
-                _LSERDYIEW { w: self }
-            }
-            #[doc = "Bit 8 - LSI ready interrupt enable"]
-            #[inline]
-            pub fn lsirdyie(&mut self) -> _LSIRDYIEW {
-                _LSIRDYIEW { w: self }
-            }
-        }
-    }
-    #[doc = "AHB1 peripheral reset register"]
-    pub struct AHB1RSTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AHB1 peripheral reset register"]
-    pub mod ahb1rstr {
-        #[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::AHB1RSTR {
-            #[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 = r" Value of the field"]
-        pub struct GPIOARSTR {
-            bits: bool,
-        }
-        impl GPIOARSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOBRSTR {
-            bits: bool,
-        }
-        impl GPIOBRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOCRSTR {
-            bits: bool,
-        }
-        impl GPIOCRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIODRSTR {
-            bits: bool,
-        }
-        impl GPIODRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOERSTR {
-            bits: bool,
-        }
-        impl GPIOERSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOFRSTR {
-            bits: bool,
-        }
-        impl GPIOFRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOGRSTR {
-            bits: bool,
-        }
-        impl GPIOGRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOHRSTR {
-            bits: bool,
-        }
-        impl GPIOHRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CRCRSTR {
-            bits: bool,
-        }
-        impl CRCRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMA1RSTR {
-            bits: bool,
-        }
-        impl DMA1RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMA2RSTR {
-            bits: bool,
-        }
-        impl DMA2RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _GPIOARSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOARSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOBRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOBRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOCRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOCRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIODRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIODRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOERSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOERSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOFRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOFRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOGRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOGRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOHRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOHRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CRCRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRCRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMA1RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMA1RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMA2RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMA2RSTW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - IO port A reset"]
-            #[inline]
-            pub fn gpioarst(&self) -> GPIOARSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOARSTR { bits }
-            }
-            #[doc = "Bit 1 - IO port B reset"]
-            #[inline]
-            pub fn gpiobrst(&self) -> GPIOBRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOBRSTR { bits }
-            }
-            #[doc = "Bit 2 - IO port C reset"]
-            #[inline]
-            pub fn gpiocrst(&self) -> GPIOCRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOCRSTR { bits }
-            }
-            #[doc = "Bit 3 - IO port D reset"]
-            #[inline]
-            pub fn gpiodrst(&self) -> GPIODRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIODRSTR { bits }
-            }
-            #[doc = "Bit 4 - IO port E reset"]
-            #[inline]
-            pub fn gpioerst(&self) -> GPIOERSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOERSTR { bits }
-            }
-            #[doc = "Bit 5 - IO port F reset"]
-            #[inline]
-            pub fn gpiofrst(&self) -> GPIOFRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOFRSTR { bits }
-            }
-            #[doc = "Bit 6 - IO port G reset"]
-            #[inline]
-            pub fn gpiogrst(&self) -> GPIOGRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOGRSTR { bits }
-            }
-            #[doc = "Bit 7 - IO port H reset"]
-            #[inline]
-            pub fn gpiohrst(&self) -> GPIOHRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOHRSTR { bits }
-            }
-            #[doc = "Bit 12 - CRC reset"]
-            #[inline]
-            pub fn crcrst(&self) -> CRCRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CRCRSTR { bits }
-            }
-            #[doc = "Bit 21 - DMA2 reset"]
-            #[inline]
-            pub fn dma1rst(&self) -> DMA1RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMA1RSTR { bits }
-            }
-            #[doc = "Bit 22 - DMA2 reset"]
-            #[inline]
-            pub fn dma2rst(&self) -> DMA2RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMA2RSTR { bits }
-            }
-        }
-        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 - IO port A reset"]
-            #[inline]
-            pub fn gpioarst(&mut self) -> _GPIOARSTW {
-                _GPIOARSTW { w: self }
-            }
-            #[doc = "Bit 1 - IO port B reset"]
-            #[inline]
-            pub fn gpiobrst(&mut self) -> _GPIOBRSTW {
-                _GPIOBRSTW { w: self }
-            }
-            #[doc = "Bit 2 - IO port C reset"]
-            #[inline]
-            pub fn gpiocrst(&mut self) -> _GPIOCRSTW {
-                _GPIOCRSTW { w: self }
-            }
-            #[doc = "Bit 3 - IO port D reset"]
-            #[inline]
-            pub fn gpiodrst(&mut self) -> _GPIODRSTW {
-                _GPIODRSTW { w: self }
-            }
-            #[doc = "Bit 4 - IO port E reset"]
-            #[inline]
-            pub fn gpioerst(&mut self) -> _GPIOERSTW {
-                _GPIOERSTW { w: self }
-            }
-            #[doc = "Bit 5 - IO port F reset"]
-            #[inline]
-            pub fn gpiofrst(&mut self) -> _GPIOFRSTW {
-                _GPIOFRSTW { w: self }
-            }
-            #[doc = "Bit 6 - IO port G reset"]
-            #[inline]
-            pub fn gpiogrst(&mut self) -> _GPIOGRSTW {
-                _GPIOGRSTW { w: self }
-            }
-            #[doc = "Bit 7 - IO port H reset"]
-            #[inline]
-            pub fn gpiohrst(&mut self) -> _GPIOHRSTW {
-                _GPIOHRSTW { w: self }
-            }
-            #[doc = "Bit 12 - CRC reset"]
-            #[inline]
-            pub fn crcrst(&mut self) -> _CRCRSTW {
-                _CRCRSTW { w: self }
-            }
-            #[doc = "Bit 21 - DMA2 reset"]
-            #[inline]
-            pub fn dma1rst(&mut self) -> _DMA1RSTW {
-                _DMA1RSTW { w: self }
-            }
-            #[doc = "Bit 22 - DMA2 reset"]
-            #[inline]
-            pub fn dma2rst(&mut self) -> _DMA2RSTW {
-                _DMA2RSTW { w: self }
-            }
-        }
-    }
-    #[doc = "AHB2 peripheral reset register"]
-    pub struct AHB2RSTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AHB2 peripheral reset register"]
-    pub mod ahb2rstr {
-        #[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::AHB2RSTR {
-            #[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 = r" Value of the field"]
-        pub struct OTGFSRSTR {
-            bits: bool,
-        }
-        impl OTGFSRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RNGRSTR {
-            bits: bool,
-        }
-        impl RNGRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CRYPRSTR {
-            bits: bool,
-        }
-        impl CRYPRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OTGFSRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTGFSRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RNGRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RNGRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CRYPRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRYPRSTW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - USB OTG FS module reset"]
-            #[inline]
-            pub fn otgfsrst(&self) -> OTGFSRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTGFSRSTR { bits }
-            }
-            #[doc = "Bit 6 - RNGRST"]
-            #[inline]
-            pub fn rngrst(&self) -> RNGRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RNGRSTR { bits }
-            }
-            #[doc = "Bit 4 - CRYP module reset"]
-            #[inline]
-            pub fn cryprst(&self) -> CRYPRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CRYPRSTR { bits }
-            }
-        }
-        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 7 - USB OTG FS module reset"]
-            #[inline]
-            pub fn otgfsrst(&mut self) -> _OTGFSRSTW {
-                _OTGFSRSTW { w: self }
-            }
-            #[doc = "Bit 6 - RNGRST"]
-            #[inline]
-            pub fn rngrst(&mut self) -> _RNGRSTW {
-                _RNGRSTW { w: self }
-            }
-            #[doc = "Bit 4 - CRYP module reset"]
-            #[inline]
-            pub fn cryprst(&mut self) -> _CRYPRSTW {
-                _CRYPRSTW { w: self }
-            }
-        }
-    }
-    #[doc = "APB1 peripheral reset register"]
-    pub struct APB1RSTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "APB1 peripheral reset register"]
-    pub mod apb1rstr {
-        #[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::APB1RSTR {
-            #[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 = r" Value of the field"]
-        pub struct TIM2RSTR {
-            bits: bool,
-        }
-        impl TIM2RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM3RSTR {
-            bits: bool,
-        }
-        impl TIM3RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM4RSTR {
-            bits: bool,
-        }
-        impl TIM4RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM5RSTR {
-            bits: bool,
-        }
-        impl TIM5RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM6RSTR {
-            bits: bool,
-        }
-        impl TIM6RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM7RSTR {
-            bits: bool,
-        }
-        impl TIM7RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM12RSTR {
-            bits: bool,
-        }
-        impl TIM12RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM13RSTR {
-            bits: bool,
-        }
-        impl TIM13RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM14RSTR {
-            bits: bool,
-        }
-        impl TIM14RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WWDGRSTR {
-            bits: bool,
-        }
-        impl WWDGRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI2RSTR {
-            bits: bool,
-        }
-        impl SPI2RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI3RSTR {
-            bits: bool,
-        }
-        impl SPI3RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART2RSTR {
-            bits: bool,
-        }
-        impl UART2RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART3RSTR {
-            bits: bool,
-        }
-        impl USART3RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C1RSTR {
-            bits: bool,
-        }
-        impl I2C1RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C2RSTR {
-            bits: bool,
-        }
-        impl I2C2RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C3RSTR {
-            bits: bool,
-        }
-        impl I2C3RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C4RSTR {
-            bits: bool,
-        }
-        impl I2C4RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN1RSTR {
-            bits: bool,
-        }
-        impl CAN1RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN2RSTR {
-            bits: bool,
-        }
-        impl CAN2RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWRRSTR {
-            bits: bool,
-        }
-        impl PWRRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LPTIMER1RSTR {
-            bits: bool,
-        }
-        impl LPTIMER1RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART4RSTR {
-            bits: bool,
-        }
-        impl USART4RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART5RSTR {
-            bits: bool,
-        }
-        impl USART5RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN3RSTR {
-            bits: bool,
-        }
-        impl CAN3RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DACRSTR {
-            bits: bool,
-        }
-        impl DACRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART7RSTR {
-            bits: bool,
-        }
-        impl UART7RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART8RSTR {
-            bits: bool,
-        }
-        impl UART8RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIM2RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM2RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM3RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM3RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM4RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM4RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM5RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM5RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM6RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM6RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM7RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM7RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM12RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM12RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM13RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM13RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM14RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM14RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WWDGRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WWDGRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI2RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI2RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI3RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI3RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART2RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART2RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART3RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART3RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C1RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C1RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C2RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C2RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C3RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C3RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C4RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C4RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN1RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN1RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN2RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN2RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWRRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWRRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LPTIMER1RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LPTIMER1RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART4RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART4RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART5RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART5RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN3RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN3RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DACRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART7RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART7RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART8RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART8RSTW<'a> {
-            #[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 - TIM2 reset"]
-            #[inline]
-            pub fn tim2rst(&self) -> TIM2RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM2RSTR { bits }
-            }
-            #[doc = "Bit 1 - TIM3 reset"]
-            #[inline]
-            pub fn tim3rst(&self) -> TIM3RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM3RSTR { bits }
-            }
-            #[doc = "Bit 2 - TIM4 reset"]
-            #[inline]
-            pub fn tim4rst(&self) -> TIM4RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM4RSTR { bits }
-            }
-            #[doc = "Bit 3 - TIM5 reset"]
-            #[inline]
-            pub fn tim5rst(&self) -> TIM5RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM5RSTR { bits }
-            }
-            #[doc = "Bit 4 - TIM6RST"]
-            #[inline]
-            pub fn tim6rst(&self) -> TIM6RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM6RSTR { bits }
-            }
-            #[doc = "Bit 5 - TIM7RST"]
-            #[inline]
-            pub fn tim7rst(&self) -> TIM7RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM7RSTR { bits }
-            }
-            #[doc = "Bit 6 - TIM12RST"]
-            #[inline]
-            pub fn tim12rst(&self) -> TIM12RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM12RSTR { bits }
-            }
-            #[doc = "Bit 7 - TIM13RST"]
-            #[inline]
-            pub fn tim13rst(&self) -> TIM13RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM13RSTR { bits }
-            }
-            #[doc = "Bit 8 - TIM14RST"]
-            #[inline]
-            pub fn tim14rst(&self) -> TIM14RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM14RSTR { bits }
-            }
-            #[doc = "Bit 11 - Window watchdog reset"]
-            #[inline]
-            pub fn wwdgrst(&self) -> WWDGRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WWDGRSTR { bits }
-            }
-            #[doc = "Bit 14 - SPI 2 reset"]
-            #[inline]
-            pub fn spi2rst(&self) -> SPI2RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI2RSTR { bits }
-            }
-            #[doc = "Bit 15 - SPI 3 reset"]
-            #[inline]
-            pub fn spi3rst(&self) -> SPI3RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI3RSTR { bits }
-            }
-            #[doc = "Bit 17 - USART 2 reset"]
-            #[inline]
-            pub fn uart2rst(&self) -> UART2RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART2RSTR { bits }
-            }
-            #[doc = "Bit 18 - USART3RST"]
-            #[inline]
-            pub fn usart3rst(&self) -> USART3RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART3RSTR { bits }
-            }
-            #[doc = "Bit 21 - I2C 1 reset"]
-            #[inline]
-            pub fn i2c1rst(&self) -> I2C1RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C1RSTR { bits }
-            }
-            #[doc = "Bit 22 - I2C 2 reset"]
-            #[inline]
-            pub fn i2c2rst(&self) -> I2C2RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C2RSTR { bits }
-            }
-            #[doc = "Bit 23 - I2C3 reset"]
-            #[inline]
-            pub fn i2c3rst(&self) -> I2C3RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C3RSTR { bits }
-            }
-            #[doc = "Bit 24 - I2C4RST"]
-            #[inline]
-            pub fn i2c4rst(&self) -> I2C4RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C4RSTR { bits }
-            }
-            #[doc = "Bit 25 - CAN1RST"]
-            #[inline]
-            pub fn can1rst(&self) -> CAN1RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN1RSTR { bits }
-            }
-            #[doc = "Bit 26 - CAN2RST"]
-            #[inline]
-            pub fn can2rst(&self) -> CAN2RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN2RSTR { bits }
-            }
-            #[doc = "Bit 28 - Power interface reset"]
-            #[inline]
-            pub fn pwrrst(&self) -> PWRRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PWRRSTR { bits }
-            }
-            #[doc = "Bit 9 - LPTimer1 reset"]
-            #[inline]
-            pub fn lptimer1rst(&self) -> LPTIMER1RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LPTIMER1RSTR { bits }
-            }
-            #[doc = "Bit 19 - USART4 reset"]
-            #[inline]
-            pub fn usart4rst(&self) -> USART4RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART4RSTR { bits }
-            }
-            #[doc = "Bit 20 - USART5 reset"]
-            #[inline]
-            pub fn usart5rst(&self) -> USART5RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART5RSTR { bits }
-            }
-            #[doc = "Bit 27 - CAN 3 reset"]
-            #[inline]
-            pub fn can3rst(&self) -> CAN3RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN3RSTR { bits }
-            }
-            #[doc = "Bit 29 - DAC reset"]
-            #[inline]
-            pub fn dacrst(&self) -> DACRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DACRSTR { bits }
-            }
-            #[doc = "Bit 30 - UART 7 reset"]
-            #[inline]
-            pub fn uart7rst(&self) -> UART7RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART7RSTR { bits }
-            }
-            #[doc = "Bit 31 - UART 8 reset"]
-            #[inline]
-            pub fn uart8rst(&self) -> UART8RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART8RSTR { bits }
-            }
-        }
-        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 - TIM2 reset"]
-            #[inline]
-            pub fn tim2rst(&mut self) -> _TIM2RSTW {
-                _TIM2RSTW { w: self }
-            }
-            #[doc = "Bit 1 - TIM3 reset"]
-            #[inline]
-            pub fn tim3rst(&mut self) -> _TIM3RSTW {
-                _TIM3RSTW { w: self }
-            }
-            #[doc = "Bit 2 - TIM4 reset"]
-            #[inline]
-            pub fn tim4rst(&mut self) -> _TIM4RSTW {
-                _TIM4RSTW { w: self }
-            }
-            #[doc = "Bit 3 - TIM5 reset"]
-            #[inline]
-            pub fn tim5rst(&mut self) -> _TIM5RSTW {
-                _TIM5RSTW { w: self }
-            }
-            #[doc = "Bit 4 - TIM6RST"]
-            #[inline]
-            pub fn tim6rst(&mut self) -> _TIM6RSTW {
-                _TIM6RSTW { w: self }
-            }
-            #[doc = "Bit 5 - TIM7RST"]
-            #[inline]
-            pub fn tim7rst(&mut self) -> _TIM7RSTW {
-                _TIM7RSTW { w: self }
-            }
-            #[doc = "Bit 6 - TIM12RST"]
-            #[inline]
-            pub fn tim12rst(&mut self) -> _TIM12RSTW {
-                _TIM12RSTW { w: self }
-            }
-            #[doc = "Bit 7 - TIM13RST"]
-            #[inline]
-            pub fn tim13rst(&mut self) -> _TIM13RSTW {
-                _TIM13RSTW { w: self }
-            }
-            #[doc = "Bit 8 - TIM14RST"]
-            #[inline]
-            pub fn tim14rst(&mut self) -> _TIM14RSTW {
-                _TIM14RSTW { w: self }
-            }
-            #[doc = "Bit 11 - Window watchdog reset"]
-            #[inline]
-            pub fn wwdgrst(&mut self) -> _WWDGRSTW {
-                _WWDGRSTW { w: self }
-            }
-            #[doc = "Bit 14 - SPI 2 reset"]
-            #[inline]
-            pub fn spi2rst(&mut self) -> _SPI2RSTW {
-                _SPI2RSTW { w: self }
-            }
-            #[doc = "Bit 15 - SPI 3 reset"]
-            #[inline]
-            pub fn spi3rst(&mut self) -> _SPI3RSTW {
-                _SPI3RSTW { w: self }
-            }
-            #[doc = "Bit 17 - USART 2 reset"]
-            #[inline]
-            pub fn uart2rst(&mut self) -> _UART2RSTW {
-                _UART2RSTW { w: self }
-            }
-            #[doc = "Bit 18 - USART3RST"]
-            #[inline]
-            pub fn usart3rst(&mut self) -> _USART3RSTW {
-                _USART3RSTW { w: self }
-            }
-            #[doc = "Bit 21 - I2C 1 reset"]
-            #[inline]
-            pub fn i2c1rst(&mut self) -> _I2C1RSTW {
-                _I2C1RSTW { w: self }
-            }
-            #[doc = "Bit 22 - I2C 2 reset"]
-            #[inline]
-            pub fn i2c2rst(&mut self) -> _I2C2RSTW {
-                _I2C2RSTW { w: self }
-            }
-            #[doc = "Bit 23 - I2C3 reset"]
-            #[inline]
-            pub fn i2c3rst(&mut self) -> _I2C3RSTW {
-                _I2C3RSTW { w: self }
-            }
-            #[doc = "Bit 24 - I2C4RST"]
-            #[inline]
-            pub fn i2c4rst(&mut self) -> _I2C4RSTW {
-                _I2C4RSTW { w: self }
-            }
-            #[doc = "Bit 25 - CAN1RST"]
-            #[inline]
-            pub fn can1rst(&mut self) -> _CAN1RSTW {
-                _CAN1RSTW { w: self }
-            }
-            #[doc = "Bit 26 - CAN2RST"]
-            #[inline]
-            pub fn can2rst(&mut self) -> _CAN2RSTW {
-                _CAN2RSTW { w: self }
-            }
-            #[doc = "Bit 28 - Power interface reset"]
-            #[inline]
-            pub fn pwrrst(&mut self) -> _PWRRSTW {
-                _PWRRSTW { w: self }
-            }
-            #[doc = "Bit 9 - LPTimer1 reset"]
-            #[inline]
-            pub fn lptimer1rst(&mut self) -> _LPTIMER1RSTW {
-                _LPTIMER1RSTW { w: self }
-            }
-            #[doc = "Bit 19 - USART4 reset"]
-            #[inline]
-            pub fn usart4rst(&mut self) -> _USART4RSTW {
-                _USART4RSTW { w: self }
-            }
-            #[doc = "Bit 20 - USART5 reset"]
-            #[inline]
-            pub fn usart5rst(&mut self) -> _USART5RSTW {
-                _USART5RSTW { w: self }
-            }
-            #[doc = "Bit 27 - CAN 3 reset"]
-            #[inline]
-            pub fn can3rst(&mut self) -> _CAN3RSTW {
-                _CAN3RSTW { w: self }
-            }
-            #[doc = "Bit 29 - DAC reset"]
-            #[inline]
-            pub fn dacrst(&mut self) -> _DACRSTW {
-                _DACRSTW { w: self }
-            }
-            #[doc = "Bit 30 - UART 7 reset"]
-            #[inline]
-            pub fn uart7rst(&mut self) -> _UART7RSTW {
-                _UART7RSTW { w: self }
-            }
-            #[doc = "Bit 31 - UART 8 reset"]
-            #[inline]
-            pub fn uart8rst(&mut self) -> _UART8RSTW {
-                _UART8RSTW { w: self }
-            }
-        }
-    }
-    #[doc = "APB2 peripheral reset register"]
-    pub struct APB2RSTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "APB2 peripheral reset register"]
-    pub mod apb2rstr {
-        #[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::APB2RSTR {
-            #[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 = r" Value of the field"]
-        pub struct TIM1RSTR {
-            bits: bool,
-        }
-        impl TIM1RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM8RSTR {
-            bits: bool,
-        }
-        impl TIM8RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART1RSTR {
-            bits: bool,
-        }
-        impl USART1RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART6RSTR {
-            bits: bool,
-        }
-        impl USART6RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADCRSTR {
-            bits: bool,
-        }
-        impl ADCRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDIORSTR {
-            bits: bool,
-        }
-        impl SDIORSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI1RSTR {
-            bits: bool,
-        }
-        impl SPI1RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SYSCFGRSTR {
-            bits: bool,
-        }
-        impl SYSCFGRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM9RSTR {
-            bits: bool,
-        }
-        impl TIM9RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM10RSTR {
-            bits: bool,
-        }
-        impl TIM10RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM11RSTR {
-            bits: bool,
-        }
-        impl TIM11RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFSDMRSTR {
-            bits: bool,
-        }
-        impl DFSDMRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART9RSTR {
-            bits: bool,
-        }
-        impl USART9RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SART10RSTR {
-            bits: bool,
-        }
-        impl SART10RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI4RSTR {
-            bits: bool,
-        }
-        impl SPI4RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI5RSTR {
-            bits: bool,
-        }
-        impl SPI5RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SAI1RSTR {
-            bits: bool,
-        }
-        impl SAI1RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFSDM2RSTR {
-            bits: bool,
-        }
-        impl DFSDM2RSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIM1RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM1RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM8RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM8RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART1RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART1RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART6RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART6RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADCRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADCRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDIORSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDIORSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI1RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI1RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SYSCFGRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SYSCFGRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM9RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM9RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM10RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM10RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM11RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM11RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFSDMRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFSDMRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART9RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART9RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SART10RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SART10RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI4RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI4RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI5RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI5RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SAI1RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SAI1RSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFSDM2RSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFSDM2RSTW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - TIM1 reset"]
-            #[inline]
-            pub fn tim1rst(&self) -> TIM1RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM1RSTR { bits }
-            }
-            #[doc = "Bit 1 - TIM8RST"]
-            #[inline]
-            pub fn tim8rst(&self) -> TIM8RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM8RSTR { bits }
-            }
-            #[doc = "Bit 4 - USART1 reset"]
-            #[inline]
-            pub fn usart1rst(&self) -> USART1RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART1RSTR { bits }
-            }
-            #[doc = "Bit 5 - USART6 reset"]
-            #[inline]
-            pub fn usart6rst(&self) -> USART6RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART6RSTR { bits }
-            }
-            #[doc = "Bit 8 - ADC interface reset (common to all ADCs)"]
-            #[inline]
-            pub fn adcrst(&self) -> ADCRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADCRSTR { bits }
-            }
-            #[doc = "Bit 11 - SDIO reset"]
-            #[inline]
-            pub fn sdiorst(&self) -> SDIORSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDIORSTR { bits }
-            }
-            #[doc = "Bit 12 - SPI 1 reset"]
-            #[inline]
-            pub fn spi1rst(&self) -> SPI1RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI1RSTR { bits }
-            }
-            #[doc = "Bit 14 - System configuration controller reset"]
-            #[inline]
-            pub fn syscfgrst(&self) -> SYSCFGRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SYSCFGRSTR { bits }
-            }
-            #[doc = "Bit 16 - TIM9 reset"]
-            #[inline]
-            pub fn tim9rst(&self) -> TIM9RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM9RSTR { bits }
-            }
-            #[doc = "Bit 17 - TIM10 reset"]
-            #[inline]
-            pub fn tim10rst(&self) -> TIM10RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM10RSTR { bits }
-            }
-            #[doc = "Bit 18 - TIM11 reset"]
-            #[inline]
-            pub fn tim11rst(&self) -> TIM11RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM11RSTR { bits }
-            }
-            #[doc = "Bit 24 - DFSDMRST"]
-            #[inline]
-            pub fn dfsdmrst(&self) -> DFSDMRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFSDMRSTR { bits }
-            }
-            #[doc = "Bit 6 - USART9 reset"]
-            #[inline]
-            pub fn usart9rst(&self) -> USART9RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART9RSTR { bits }
-            }
-            #[doc = "Bit 7 - USART10 reset"]
-            #[inline]
-            pub fn sart10rst(&self) -> SART10RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SART10RSTR { bits }
-            }
-            #[doc = "Bit 13 - SPI4 reset"]
-            #[inline]
-            pub fn spi4rst(&self) -> SPI4RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI4RSTR { bits }
-            }
-            #[doc = "Bit 20 - SPI5RST"]
-            #[inline]
-            pub fn spi5rst(&self) -> SPI5RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI5RSTR { bits }
-            }
-            #[doc = "Bit 22 - SAI1 reset"]
-            #[inline]
-            pub fn sai1rst(&self) -> SAI1RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SAI1RSTR { bits }
-            }
-            #[doc = "Bit 25 - DFSDM2 reset"]
-            #[inline]
-            pub fn dfsdm2rst(&self) -> DFSDM2RSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFSDM2RSTR { bits }
-            }
-        }
-        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 - TIM1 reset"]
-            #[inline]
-            pub fn tim1rst(&mut self) -> _TIM1RSTW {
-                _TIM1RSTW { w: self }
-            }
-            #[doc = "Bit 1 - TIM8RST"]
-            #[inline]
-            pub fn tim8rst(&mut self) -> _TIM8RSTW {
-                _TIM8RSTW { w: self }
-            }
-            #[doc = "Bit 4 - USART1 reset"]
-            #[inline]
-            pub fn usart1rst(&mut self) -> _USART1RSTW {
-                _USART1RSTW { w: self }
-            }
-            #[doc = "Bit 5 - USART6 reset"]
-            #[inline]
-            pub fn usart6rst(&mut self) -> _USART6RSTW {
-                _USART6RSTW { w: self }
-            }
-            #[doc = "Bit 8 - ADC interface reset (common to all ADCs)"]
-            #[inline]
-            pub fn adcrst(&mut self) -> _ADCRSTW {
-                _ADCRSTW { w: self }
-            }
-            #[doc = "Bit 11 - SDIO reset"]
-            #[inline]
-            pub fn sdiorst(&mut self) -> _SDIORSTW {
-                _SDIORSTW { w: self }
-            }
-            #[doc = "Bit 12 - SPI 1 reset"]
-            #[inline]
-            pub fn spi1rst(&mut self) -> _SPI1RSTW {
-                _SPI1RSTW { w: self }
-            }
-            #[doc = "Bit 14 - System configuration controller reset"]
-            #[inline]
-            pub fn syscfgrst(&mut self) -> _SYSCFGRSTW {
-                _SYSCFGRSTW { w: self }
-            }
-            #[doc = "Bit 16 - TIM9 reset"]
-            #[inline]
-            pub fn tim9rst(&mut self) -> _TIM9RSTW {
-                _TIM9RSTW { w: self }
-            }
-            #[doc = "Bit 17 - TIM10 reset"]
-            #[inline]
-            pub fn tim10rst(&mut self) -> _TIM10RSTW {
-                _TIM10RSTW { w: self }
-            }
-            #[doc = "Bit 18 - TIM11 reset"]
-            #[inline]
-            pub fn tim11rst(&mut self) -> _TIM11RSTW {
-                _TIM11RSTW { w: self }
-            }
-            #[doc = "Bit 24 - DFSDMRST"]
-            #[inline]
-            pub fn dfsdmrst(&mut self) -> _DFSDMRSTW {
-                _DFSDMRSTW { w: self }
-            }
-            #[doc = "Bit 6 - USART9 reset"]
-            #[inline]
-            pub fn usart9rst(&mut self) -> _USART9RSTW {
-                _USART9RSTW { w: self }
-            }
-            #[doc = "Bit 7 - USART10 reset"]
-            #[inline]
-            pub fn sart10rst(&mut self) -> _SART10RSTW {
-                _SART10RSTW { w: self }
-            }
-            #[doc = "Bit 13 - SPI4 reset"]
-            #[inline]
-            pub fn spi4rst(&mut self) -> _SPI4RSTW {
-                _SPI4RSTW { w: self }
-            }
-            #[doc = "Bit 20 - SPI5RST"]
-            #[inline]
-            pub fn spi5rst(&mut self) -> _SPI5RSTW {
-                _SPI5RSTW { w: self }
-            }
-            #[doc = "Bit 22 - SAI1 reset"]
-            #[inline]
-            pub fn sai1rst(&mut self) -> _SAI1RSTW {
-                _SAI1RSTW { w: self }
-            }
-            #[doc = "Bit 25 - DFSDM2 reset"]
-            #[inline]
-            pub fn dfsdm2rst(&mut self) -> _DFSDM2RSTW {
-                _DFSDM2RSTW { w: self }
-            }
-        }
-    }
-    #[doc = "AHB1 peripheral clock register"]
-    pub struct AHB1ENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AHB1 peripheral clock register"]
-    pub mod ahb1enr {
-        #[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::AHB1ENR {
-            #[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 = r" Value of the field"]
-        pub struct GPIOAENR {
-            bits: bool,
-        }
-        impl GPIOAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOBENR {
-            bits: bool,
-        }
-        impl GPIOBENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOCENR {
-            bits: bool,
-        }
-        impl GPIOCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIODENR {
-            bits: bool,
-        }
-        impl GPIODENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOEENR {
-            bits: bool,
-        }
-        impl GPIOEENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOFENR {
-            bits: bool,
-        }
-        impl GPIOFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOGENR {
-            bits: bool,
-        }
-        impl GPIOGENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOHENR {
-            bits: bool,
-        }
-        impl GPIOHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CRCENR {
-            bits: bool,
-        }
-        impl CRCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMA1ENR {
-            bits: bool,
-        }
-        impl DMA1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMA2ENR {
-            bits: bool,
-        }
-        impl DMA2ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _GPIOAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOBENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOBENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIODENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIODENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOEENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOEENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOFENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOGENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOGENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CRCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMA1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMA1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMA2ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMA2ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - IO port A clock enable"]
-            #[inline]
-            pub fn gpioaen(&self) -> GPIOAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOAENR { bits }
-            }
-            #[doc = "Bit 1 - IO port B clock enable"]
-            #[inline]
-            pub fn gpioben(&self) -> GPIOBENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOBENR { bits }
-            }
-            #[doc = "Bit 2 - IO port C clock enable"]
-            #[inline]
-            pub fn gpiocen(&self) -> GPIOCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOCENR { bits }
-            }
-            #[doc = "Bit 3 - IO port D clock enable"]
-            #[inline]
-            pub fn gpioden(&self) -> GPIODENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIODENR { bits }
-            }
-            #[doc = "Bit 4 - IO port E clock enable"]
-            #[inline]
-            pub fn gpioeen(&self) -> GPIOEENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOEENR { bits }
-            }
-            #[doc = "Bit 5 - IO port F clock enable"]
-            #[inline]
-            pub fn gpiofen(&self) -> GPIOFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOFENR { bits }
-            }
-            #[doc = "Bit 6 - IO port G clock enable"]
-            #[inline]
-            pub fn gpiogen(&self) -> GPIOGENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOGENR { bits }
-            }
-            #[doc = "Bit 7 - IO port H clock enable"]
-            #[inline]
-            pub fn gpiohen(&self) -> GPIOHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOHENR { bits }
-            }
-            #[doc = "Bit 12 - CRC clock enable"]
-            #[inline]
-            pub fn crcen(&self) -> CRCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CRCENR { bits }
-            }
-            #[doc = "Bit 21 - DMA1 clock enable"]
-            #[inline]
-            pub fn dma1en(&self) -> DMA1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMA1ENR { bits }
-            }
-            #[doc = "Bit 22 - DMA2 clock enable"]
-            #[inline]
-            pub fn dma2en(&self) -> DMA2ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMA2ENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0010_0000 }
-            }
-            #[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 - IO port A clock enable"]
-            #[inline]
-            pub fn gpioaen(&mut self) -> _GPIOAENW {
-                _GPIOAENW { w: self }
-            }
-            #[doc = "Bit 1 - IO port B clock enable"]
-            #[inline]
-            pub fn gpioben(&mut self) -> _GPIOBENW {
-                _GPIOBENW { w: self }
-            }
-            #[doc = "Bit 2 - IO port C clock enable"]
-            #[inline]
-            pub fn gpiocen(&mut self) -> _GPIOCENW {
-                _GPIOCENW { w: self }
-            }
-            #[doc = "Bit 3 - IO port D clock enable"]
-            #[inline]
-            pub fn gpioden(&mut self) -> _GPIODENW {
-                _GPIODENW { w: self }
-            }
-            #[doc = "Bit 4 - IO port E clock enable"]
-            #[inline]
-            pub fn gpioeen(&mut self) -> _GPIOEENW {
-                _GPIOEENW { w: self }
-            }
-            #[doc = "Bit 5 - IO port F clock enable"]
-            #[inline]
-            pub fn gpiofen(&mut self) -> _GPIOFENW {
-                _GPIOFENW { w: self }
-            }
-            #[doc = "Bit 6 - IO port G clock enable"]
-            #[inline]
-            pub fn gpiogen(&mut self) -> _GPIOGENW {
-                _GPIOGENW { w: self }
-            }
-            #[doc = "Bit 7 - IO port H clock enable"]
-            #[inline]
-            pub fn gpiohen(&mut self) -> _GPIOHENW {
-                _GPIOHENW { w: self }
-            }
-            #[doc = "Bit 12 - CRC clock enable"]
-            #[inline]
-            pub fn crcen(&mut self) -> _CRCENW {
-                _CRCENW { w: self }
-            }
-            #[doc = "Bit 21 - DMA1 clock enable"]
-            #[inline]
-            pub fn dma1en(&mut self) -> _DMA1ENW {
-                _DMA1ENW { w: self }
-            }
-            #[doc = "Bit 22 - DMA2 clock enable"]
-            #[inline]
-            pub fn dma2en(&mut self) -> _DMA2ENW {
-                _DMA2ENW { w: self }
-            }
-        }
-    }
-    #[doc = "AHB2 peripheral clock enable register"]
-    pub struct AHB2ENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AHB2 peripheral clock enable register"]
-    pub mod ahb2enr {
-        #[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::AHB2ENR {
-            #[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 = r" Value of the field"]
-        pub struct OTGFSENR {
-            bits: bool,
-        }
-        impl OTGFSENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RNGENR {
-            bits: bool,
-        }
-        impl RNGENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CRYPENR {
-            bits: bool,
-        }
-        impl CRYPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OTGFSENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTGFSENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RNGENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RNGENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CRYPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRYPENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - USB OTG FS clock enable"]
-            #[inline]
-            pub fn otgfsen(&self) -> OTGFSENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTGFSENR { bits }
-            }
-            #[doc = "Bit 6 - RNGEN"]
-            #[inline]
-            pub fn rngen(&self) -> RNGENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RNGENR { bits }
-            }
-            #[doc = "Bit 4 - CRYP clock enable"]
-            #[inline]
-            pub fn crypen(&self) -> CRYPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CRYPENR { bits }
-            }
-        }
-        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 7 - USB OTG FS clock enable"]
-            #[inline]
-            pub fn otgfsen(&mut self) -> _OTGFSENW {
-                _OTGFSENW { w: self }
-            }
-            #[doc = "Bit 6 - RNGEN"]
-            #[inline]
-            pub fn rngen(&mut self) -> _RNGENW {
-                _RNGENW { w: self }
-            }
-            #[doc = "Bit 4 - CRYP clock enable"]
-            #[inline]
-            pub fn crypen(&mut self) -> _CRYPENW {
-                _CRYPENW { w: self }
-            }
-        }
-    }
-    #[doc = "APB1 peripheral clock enable register"]
-    pub struct APB1ENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "APB1 peripheral clock enable register"]
-    pub mod apb1enr {
-        #[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::APB1ENR {
-            #[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 = r" Value of the field"]
-        pub struct TIM2ENR {
-            bits: bool,
-        }
-        impl TIM2ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM3ENR {
-            bits: bool,
-        }
-        impl TIM3ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM4ENR {
-            bits: bool,
-        }
-        impl TIM4ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM5ENR {
-            bits: bool,
-        }
-        impl TIM5ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM6ENR {
-            bits: bool,
-        }
-        impl TIM6ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM7ENR {
-            bits: bool,
-        }
-        impl TIM7ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM12ENR {
-            bits: bool,
-        }
-        impl TIM12ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM13ENR {
-            bits: bool,
-        }
-        impl TIM13ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM14ENR {
-            bits: bool,
-        }
-        impl TIM14ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WWDGENR {
-            bits: bool,
-        }
-        impl WWDGENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI2ENR {
-            bits: bool,
-        }
-        impl SPI2ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI3ENR {
-            bits: bool,
-        }
-        impl SPI3ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART2ENR {
-            bits: bool,
-        }
-        impl USART2ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART3ENR {
-            bits: bool,
-        }
-        impl USART3ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C1ENR {
-            bits: bool,
-        }
-        impl I2C1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C2ENR {
-            bits: bool,
-        }
-        impl I2C2ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C3ENR {
-            bits: bool,
-        }
-        impl I2C3ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C4ENR {
-            bits: bool,
-        }
-        impl I2C4ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN1ENR {
-            bits: bool,
-        }
-        impl CAN1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN2ENR {
-            bits: bool,
-        }
-        impl CAN2ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWRENR {
-            bits: bool,
-        }
-        impl PWRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LPTIMER1ENR {
-            bits: bool,
-        }
-        impl LPTIMER1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTCAPBR {
-            bits: bool,
-        }
-        impl RTCAPBR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART4ENR {
-            bits: bool,
-        }
-        impl UART4ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART5ENR {
-            bits: bool,
-        }
-        impl UART5ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN3ENR {
-            bits: bool,
-        }
-        impl CAN3ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DACENR {
-            bits: bool,
-        }
-        impl DACENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART7ENR {
-            bits: bool,
-        }
-        impl UART7ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART8ENR {
-            bits: bool,
-        }
-        impl UART8ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIM2ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM2ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM3ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM3ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM4ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM4ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM5ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM5ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM6ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM6ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM7ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM7ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM12ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM12ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM13ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM13ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM14ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM14ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WWDGENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WWDGENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI2ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI2ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI3ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI3ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART2ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART2ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART3ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART3ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C2ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C2ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C3ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C3ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C4ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C4ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN2ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN2ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LPTIMER1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LPTIMER1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTCAPBW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTCAPBW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART4ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART4ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART5ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART5ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN3ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN3ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DACENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART7ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART7ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART8ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART8ENW<'a> {
-            #[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 - TIM2 clock enable"]
-            #[inline]
-            pub fn tim2en(&self) -> TIM2ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM2ENR { bits }
-            }
-            #[doc = "Bit 1 - TIM3 clock enable"]
-            #[inline]
-            pub fn tim3en(&self) -> TIM3ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM3ENR { bits }
-            }
-            #[doc = "Bit 2 - TIM4 clock enable"]
-            #[inline]
-            pub fn tim4en(&self) -> TIM4ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM4ENR { bits }
-            }
-            #[doc = "Bit 3 - TIM5 clock enable"]
-            #[inline]
-            pub fn tim5en(&self) -> TIM5ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM5ENR { bits }
-            }
-            #[doc = "Bit 4 - TIM6EN"]
-            #[inline]
-            pub fn tim6en(&self) -> TIM6ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM6ENR { bits }
-            }
-            #[doc = "Bit 5 - TIM7EN"]
-            #[inline]
-            pub fn tim7en(&self) -> TIM7ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM7ENR { bits }
-            }
-            #[doc = "Bit 6 - TIM12EN"]
-            #[inline]
-            pub fn tim12en(&self) -> TIM12ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM12ENR { bits }
-            }
-            #[doc = "Bit 7 - TIM13EN"]
-            #[inline]
-            pub fn tim13en(&self) -> TIM13ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM13ENR { bits }
-            }
-            #[doc = "Bit 8 - TIM14EN"]
-            #[inline]
-            pub fn tim14en(&self) -> TIM14ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM14ENR { bits }
-            }
-            #[doc = "Bit 11 - Window watchdog clock enable"]
-            #[inline]
-            pub fn wwdgen(&self) -> WWDGENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WWDGENR { bits }
-            }
-            #[doc = "Bit 14 - SPI2 clock enable"]
-            #[inline]
-            pub fn spi2en(&self) -> SPI2ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI2ENR { bits }
-            }
-            #[doc = "Bit 15 - SPI3 clock enable"]
-            #[inline]
-            pub fn spi3en(&self) -> SPI3ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI3ENR { bits }
-            }
-            #[doc = "Bit 17 - USART 2 clock enable"]
-            #[inline]
-            pub fn usart2en(&self) -> USART2ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART2ENR { bits }
-            }
-            #[doc = "Bit 18 - USART3EN"]
-            #[inline]
-            pub fn usart3en(&self) -> USART3ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART3ENR { bits }
-            }
-            #[doc = "Bit 21 - I2C1 clock enable"]
-            #[inline]
-            pub fn i2c1en(&self) -> I2C1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C1ENR { bits }
-            }
-            #[doc = "Bit 22 - I2C2 clock enable"]
-            #[inline]
-            pub fn i2c2en(&self) -> I2C2ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C2ENR { bits }
-            }
-            #[doc = "Bit 23 - I2C3 clock enable"]
-            #[inline]
-            pub fn i2c3en(&self) -> I2C3ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C3ENR { bits }
-            }
-            #[doc = "Bit 24 - I2C4EN"]
-            #[inline]
-            pub fn i2c4en(&self) -> I2C4ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C4ENR { bits }
-            }
-            #[doc = "Bit 25 - CAN1EN"]
-            #[inline]
-            pub fn can1en(&self) -> CAN1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN1ENR { bits }
-            }
-            #[doc = "Bit 26 - CAN2EN"]
-            #[inline]
-            pub fn can2en(&self) -> CAN2ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN2ENR { bits }
-            }
-            #[doc = "Bit 28 - Power interface clock enable"]
-            #[inline]
-            pub fn pwren(&self) -> PWRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PWRENR { bits }
-            }
-            #[doc = "Bit 9 - LPTimer 1 clock enable"]
-            #[inline]
-            pub fn lptimer1en(&self) -> LPTIMER1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LPTIMER1ENR { bits }
-            }
-            #[doc = "Bit 10 - clock enable"]
-            #[inline]
-            pub fn rtcapb(&self) -> RTCAPBR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTCAPBR { bits }
-            }
-            #[doc = "Bit 19 - UART 4 clock enable"]
-            #[inline]
-            pub fn uart4en(&self) -> UART4ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART4ENR { bits }
-            }
-            #[doc = "Bit 20 - UART 5 clock enable"]
-            #[inline]
-            pub fn uart5en(&self) -> UART5ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART5ENR { bits }
-            }
-            #[doc = "Bit 27 - CAN 3 clock enable"]
-            #[inline]
-            pub fn can3en(&self) -> CAN3ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN3ENR { bits }
-            }
-            #[doc = "Bit 29 - DAC clock enable"]
-            #[inline]
-            pub fn dacen(&self) -> DACENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DACENR { bits }
-            }
-            #[doc = "Bit 30 - UART7 clock enable"]
-            #[inline]
-            pub fn uart7en(&self) -> UART7ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART7ENR { bits }
-            }
-            #[doc = "Bit 31 - UART8 clock enable"]
-            #[inline]
-            pub fn uart8en(&self) -> UART8ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART8ENR { bits }
-            }
-        }
-        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 - TIM2 clock enable"]
-            #[inline]
-            pub fn tim2en(&mut self) -> _TIM2ENW {
-                _TIM2ENW { w: self }
-            }
-            #[doc = "Bit 1 - TIM3 clock enable"]
-            #[inline]
-            pub fn tim3en(&mut self) -> _TIM3ENW {
-                _TIM3ENW { w: self }
-            }
-            #[doc = "Bit 2 - TIM4 clock enable"]
-            #[inline]
-            pub fn tim4en(&mut self) -> _TIM4ENW {
-                _TIM4ENW { w: self }
-            }
-            #[doc = "Bit 3 - TIM5 clock enable"]
-            #[inline]
-            pub fn tim5en(&mut self) -> _TIM5ENW {
-                _TIM5ENW { w: self }
-            }
-            #[doc = "Bit 4 - TIM6EN"]
-            #[inline]
-            pub fn tim6en(&mut self) -> _TIM6ENW {
-                _TIM6ENW { w: self }
-            }
-            #[doc = "Bit 5 - TIM7EN"]
-            #[inline]
-            pub fn tim7en(&mut self) -> _TIM7ENW {
-                _TIM7ENW { w: self }
-            }
-            #[doc = "Bit 6 - TIM12EN"]
-            #[inline]
-            pub fn tim12en(&mut self) -> _TIM12ENW {
-                _TIM12ENW { w: self }
-            }
-            #[doc = "Bit 7 - TIM13EN"]
-            #[inline]
-            pub fn tim13en(&mut self) -> _TIM13ENW {
-                _TIM13ENW { w: self }
-            }
-            #[doc = "Bit 8 - TIM14EN"]
-            #[inline]
-            pub fn tim14en(&mut self) -> _TIM14ENW {
-                _TIM14ENW { w: self }
-            }
-            #[doc = "Bit 11 - Window watchdog clock enable"]
-            #[inline]
-            pub fn wwdgen(&mut self) -> _WWDGENW {
-                _WWDGENW { w: self }
-            }
-            #[doc = "Bit 14 - SPI2 clock enable"]
-            #[inline]
-            pub fn spi2en(&mut self) -> _SPI2ENW {
-                _SPI2ENW { w: self }
-            }
-            #[doc = "Bit 15 - SPI3 clock enable"]
-            #[inline]
-            pub fn spi3en(&mut self) -> _SPI3ENW {
-                _SPI3ENW { w: self }
-            }
-            #[doc = "Bit 17 - USART 2 clock enable"]
-            #[inline]
-            pub fn usart2en(&mut self) -> _USART2ENW {
-                _USART2ENW { w: self }
-            }
-            #[doc = "Bit 18 - USART3EN"]
-            #[inline]
-            pub fn usart3en(&mut self) -> _USART3ENW {
-                _USART3ENW { w: self }
-            }
-            #[doc = "Bit 21 - I2C1 clock enable"]
-            #[inline]
-            pub fn i2c1en(&mut self) -> _I2C1ENW {
-                _I2C1ENW { w: self }
-            }
-            #[doc = "Bit 22 - I2C2 clock enable"]
-            #[inline]
-            pub fn i2c2en(&mut self) -> _I2C2ENW {
-                _I2C2ENW { w: self }
-            }
-            #[doc = "Bit 23 - I2C3 clock enable"]
-            #[inline]
-            pub fn i2c3en(&mut self) -> _I2C3ENW {
-                _I2C3ENW { w: self }
-            }
-            #[doc = "Bit 24 - I2C4EN"]
-            #[inline]
-            pub fn i2c4en(&mut self) -> _I2C4ENW {
-                _I2C4ENW { w: self }
-            }
-            #[doc = "Bit 25 - CAN1EN"]
-            #[inline]
-            pub fn can1en(&mut self) -> _CAN1ENW {
-                _CAN1ENW { w: self }
-            }
-            #[doc = "Bit 26 - CAN2EN"]
-            #[inline]
-            pub fn can2en(&mut self) -> _CAN2ENW {
-                _CAN2ENW { w: self }
-            }
-            #[doc = "Bit 28 - Power interface clock enable"]
-            #[inline]
-            pub fn pwren(&mut self) -> _PWRENW {
-                _PWRENW { w: self }
-            }
-            #[doc = "Bit 9 - LPTimer 1 clock enable"]
-            #[inline]
-            pub fn lptimer1en(&mut self) -> _LPTIMER1ENW {
-                _LPTIMER1ENW { w: self }
-            }
-            #[doc = "Bit 10 - clock enable"]
-            #[inline]
-            pub fn rtcapb(&mut self) -> _RTCAPBW {
-                _RTCAPBW { w: self }
-            }
-            #[doc = "Bit 19 - UART 4 clock enable"]
-            #[inline]
-            pub fn uart4en(&mut self) -> _UART4ENW {
-                _UART4ENW { w: self }
-            }
-            #[doc = "Bit 20 - UART 5 clock enable"]
-            #[inline]
-            pub fn uart5en(&mut self) -> _UART5ENW {
-                _UART5ENW { w: self }
-            }
-            #[doc = "Bit 27 - CAN 3 clock enable"]
-            #[inline]
-            pub fn can3en(&mut self) -> _CAN3ENW {
-                _CAN3ENW { w: self }
-            }
-            #[doc = "Bit 29 - DAC clock enable"]
-            #[inline]
-            pub fn dacen(&mut self) -> _DACENW {
-                _DACENW { w: self }
-            }
-            #[doc = "Bit 30 - UART7 clock enable"]
-            #[inline]
-            pub fn uart7en(&mut self) -> _UART7ENW {
-                _UART7ENW { w: self }
-            }
-            #[doc = "Bit 31 - UART8 clock enable"]
-            #[inline]
-            pub fn uart8en(&mut self) -> _UART8ENW {
-                _UART8ENW { w: self }
-            }
-        }
-    }
-    #[doc = "APB2 peripheral clock enable register"]
-    pub struct APB2ENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "APB2 peripheral clock enable register"]
-    pub mod apb2enr {
-        #[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::APB2ENR {
-            #[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 = r" Value of the field"]
-        pub struct TIM1ENR {
-            bits: bool,
-        }
-        impl TIM1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM8ENR {
-            bits: bool,
-        }
-        impl TIM8ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART1ENR {
-            bits: bool,
-        }
-        impl USART1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART6ENR {
-            bits: bool,
-        }
-        impl USART6ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADC1ENR {
-            bits: bool,
-        }
-        impl ADC1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDIOENR {
-            bits: bool,
-        }
-        impl SDIOENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI1ENR {
-            bits: bool,
-        }
-        impl SPI1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI4ENR {
-            bits: bool,
-        }
-        impl SPI4ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SYSCFGENR {
-            bits: bool,
-        }
-        impl SYSCFGENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM9ENR {
-            bits: bool,
-        }
-        impl TIM9ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM10ENR {
-            bits: bool,
-        }
-        impl TIM10ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM11ENR {
-            bits: bool,
-        }
-        impl TIM11ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFSDMENR {
-            bits: bool,
-        }
-        impl DFSDMENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI5ENR {
-            bits: bool,
-        }
-        impl SPI5ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SAI1ENR {
-            bits: bool,
-        }
-        impl SAI1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFSDM2ENR {
-            bits: bool,
-        }
-        impl DFSDM2ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIM1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM8ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM8ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART6ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART6ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADC1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADC1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDIOENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDIOENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI4ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI4ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SYSCFGENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SYSCFGENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM9ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM9ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM10ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM10ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM11ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM11ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFSDMENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFSDMENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI5ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI5ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SAI1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SAI1ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFSDM2ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFSDM2ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - TIM1 clock enable"]
-            #[inline]
-            pub fn tim1en(&self) -> TIM1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM1ENR { bits }
-            }
-            #[doc = "Bit 1 - TIM8EN"]
-            #[inline]
-            pub fn tim8en(&self) -> TIM8ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM8ENR { bits }
-            }
-            #[doc = "Bit 4 - USART1 clock enable"]
-            #[inline]
-            pub fn usart1en(&self) -> USART1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART1ENR { bits }
-            }
-            #[doc = "Bit 5 - USART6 clock enable"]
-            #[inline]
-            pub fn usart6en(&self) -> USART6ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART6ENR { bits }
-            }
-            #[doc = "Bit 8 - ADC1 clock enable"]
-            #[inline]
-            pub fn adc1en(&self) -> ADC1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADC1ENR { bits }
-            }
-            #[doc = "Bit 11 - SDIO clock enable"]
-            #[inline]
-            pub fn sdioen(&self) -> SDIOENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDIOENR { bits }
-            }
-            #[doc = "Bit 12 - SPI1 clock enable"]
-            #[inline]
-            pub fn spi1en(&self) -> SPI1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI1ENR { bits }
-            }
-            #[doc = "Bit 13 - SPI4 clock enable"]
-            #[inline]
-            pub fn spi4en(&self) -> SPI4ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI4ENR { bits }
-            }
-            #[doc = "Bit 14 - System configuration controller clock enable"]
-            #[inline]
-            pub fn syscfgen(&self) -> SYSCFGENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SYSCFGENR { bits }
-            }
-            #[doc = "Bit 16 - TIM9 clock enable"]
-            #[inline]
-            pub fn tim9en(&self) -> TIM9ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM9ENR { bits }
-            }
-            #[doc = "Bit 17 - TIM10 clock enable"]
-            #[inline]
-            pub fn tim10en(&self) -> TIM10ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM10ENR { bits }
-            }
-            #[doc = "Bit 18 - TIM11 clock enable"]
-            #[inline]
-            pub fn tim11en(&self) -> TIM11ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM11ENR { bits }
-            }
-            #[doc = "Bit 24 - DFSDMEN"]
-            #[inline]
-            pub fn dfsdmen(&self) -> DFSDMENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFSDMENR { bits }
-            }
-            #[doc = "Bit 20 - SPI5 clock enable"]
-            #[inline]
-            pub fn spi5en(&self) -> SPI5ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI5ENR { bits }
-            }
-            #[doc = "Bit 22 - SAI 1 clock enable"]
-            #[inline]
-            pub fn sai1en(&self) -> SAI1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SAI1ENR { bits }
-            }
-            #[doc = "Bit 25 - DFSDM2 clock enable"]
-            #[inline]
-            pub fn dfsdm2en(&self) -> DFSDM2ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFSDM2ENR { bits }
-            }
-        }
-        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 - TIM1 clock enable"]
-            #[inline]
-            pub fn tim1en(&mut self) -> _TIM1ENW {
-                _TIM1ENW { w: self }
-            }
-            #[doc = "Bit 1 - TIM8EN"]
-            #[inline]
-            pub fn tim8en(&mut self) -> _TIM8ENW {
-                _TIM8ENW { w: self }
-            }
-            #[doc = "Bit 4 - USART1 clock enable"]
-            #[inline]
-            pub fn usart1en(&mut self) -> _USART1ENW {
-                _USART1ENW { w: self }
-            }
-            #[doc = "Bit 5 - USART6 clock enable"]
-            #[inline]
-            pub fn usart6en(&mut self) -> _USART6ENW {
-                _USART6ENW { w: self }
-            }
-            #[doc = "Bit 8 - ADC1 clock enable"]
-            #[inline]
-            pub fn adc1en(&mut self) -> _ADC1ENW {
-                _ADC1ENW { w: self }
-            }
-            #[doc = "Bit 11 - SDIO clock enable"]
-            #[inline]
-            pub fn sdioen(&mut self) -> _SDIOENW {
-                _SDIOENW { w: self }
-            }
-            #[doc = "Bit 12 - SPI1 clock enable"]
-            #[inline]
-            pub fn spi1en(&mut self) -> _SPI1ENW {
-                _SPI1ENW { w: self }
-            }
-            #[doc = "Bit 13 - SPI4 clock enable"]
-            #[inline]
-            pub fn spi4en(&mut self) -> _SPI4ENW {
-                _SPI4ENW { w: self }
-            }
-            #[doc = "Bit 14 - System configuration controller clock enable"]
-            #[inline]
-            pub fn syscfgen(&mut self) -> _SYSCFGENW {
-                _SYSCFGENW { w: self }
-            }
-            #[doc = "Bit 16 - TIM9 clock enable"]
-            #[inline]
-            pub fn tim9en(&mut self) -> _TIM9ENW {
-                _TIM9ENW { w: self }
-            }
-            #[doc = "Bit 17 - TIM10 clock enable"]
-            #[inline]
-            pub fn tim10en(&mut self) -> _TIM10ENW {
-                _TIM10ENW { w: self }
-            }
-            #[doc = "Bit 18 - TIM11 clock enable"]
-            #[inline]
-            pub fn tim11en(&mut self) -> _TIM11ENW {
-                _TIM11ENW { w: self }
-            }
-            #[doc = "Bit 24 - DFSDMEN"]
-            #[inline]
-            pub fn dfsdmen(&mut self) -> _DFSDMENW {
-                _DFSDMENW { w: self }
-            }
-            #[doc = "Bit 20 - SPI5 clock enable"]
-            #[inline]
-            pub fn spi5en(&mut self) -> _SPI5ENW {
-                _SPI5ENW { w: self }
-            }
-            #[doc = "Bit 22 - SAI 1 clock enable"]
-            #[inline]
-            pub fn sai1en(&mut self) -> _SAI1ENW {
-                _SAI1ENW { w: self }
-            }
-            #[doc = "Bit 25 - DFSDM2 clock enable"]
-            #[inline]
-            pub fn dfsdm2en(&mut self) -> _DFSDM2ENW {
-                _DFSDM2ENW { w: self }
-            }
-        }
-    }
-    #[doc = "AHB1 peripheral clock enable in low power mode register"]
-    pub struct AHB1LPENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AHB1 peripheral clock enable in low power mode register"]
-    pub mod ahb1lpenr {
-        #[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::AHB1LPENR {
-            #[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 = r" Value of the field"]
-        pub struct GPIOALPENR {
-            bits: bool,
-        }
-        impl GPIOALPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOBLPENR {
-            bits: bool,
-        }
-        impl GPIOBLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOCLPENR {
-            bits: bool,
-        }
-        impl GPIOCLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIODLPENR {
-            bits: bool,
-        }
-        impl GPIODLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOELPENR {
-            bits: bool,
-        }
-        impl GPIOELPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOFLPENR {
-            bits: bool,
-        }
-        impl GPIOFLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOGLPENR {
-            bits: bool,
-        }
-        impl GPIOGLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GPIOHLPENR {
-            bits: bool,
-        }
-        impl GPIOHLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CRCLPENR {
-            bits: bool,
-        }
-        impl CRCLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FLITFLPENR {
-            bits: bool,
-        }
-        impl FLITFLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SRAM1LPENR {
-            bits: bool,
-        }
-        impl SRAM1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMA1LPENR {
-            bits: bool,
-        }
-        impl DMA1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMA2LPENR {
-            bits: bool,
-        }
-        impl DMA2LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SRAM2LPENR {
-            bits: bool,
-        }
-        impl SRAM2LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _GPIOALPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOALPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOBLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOBLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOCLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOCLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIODLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIODLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOELPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOELPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOFLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOFLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOGLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOGLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GPIOHLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GPIOHLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CRCLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRCLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FLITFLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FLITFLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SRAM1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SRAM1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMA1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMA1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMA2LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMA2LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SRAM2LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SRAM2LPENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - IO port A clock enable during sleep mode"]
-            #[inline]
-            pub fn gpioalpen(&self) -> GPIOALPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOALPENR { bits }
-            }
-            #[doc = "Bit 1 - IO port B clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpioblpen(&self) -> GPIOBLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOBLPENR { bits }
-            }
-            #[doc = "Bit 2 - IO port C clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpioclpen(&self) -> GPIOCLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOCLPENR { bits }
-            }
-            #[doc = "Bit 3 - IO port D clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpiodlpen(&self) -> GPIODLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIODLPENR { bits }
-            }
-            #[doc = "Bit 4 - IO port E clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpioelpen(&self) -> GPIOELPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOELPENR { bits }
-            }
-            #[doc = "Bit 5 - IO port F clock enable during sleep mode"]
-            #[inline]
-            pub fn gpioflpen(&self) -> GPIOFLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOFLPENR { bits }
-            }
-            #[doc = "Bit 6 - IO port G clock enable during sleep mode"]
-            #[inline]
-            pub fn gpioglpen(&self) -> GPIOGLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOGLPENR { bits }
-            }
-            #[doc = "Bit 7 - IO port H clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpiohlpen(&self) -> GPIOHLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GPIOHLPENR { bits }
-            }
-            #[doc = "Bit 12 - CRC clock enable during Sleep mode"]
-            #[inline]
-            pub fn crclpen(&self) -> CRCLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CRCLPENR { bits }
-            }
-            #[doc = "Bit 15 - Flash interface clock enable during Sleep mode"]
-            #[inline]
-            pub fn flitflpen(&self) -> FLITFLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FLITFLPENR { bits }
-            }
-            #[doc = "Bit 16 - SRAM 1interface clock enable during Sleep mode"]
-            #[inline]
-            pub fn sram1lpen(&self) -> SRAM1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRAM1LPENR { bits }
-            }
-            #[doc = "Bit 21 - DMA1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn dma1lpen(&self) -> DMA1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMA1LPENR { bits }
-            }
-            #[doc = "Bit 22 - DMA2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn dma2lpen(&self) -> DMA2LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMA2LPENR { bits }
-            }
-            #[doc = "Bit 17 - SRAM2interface clock enable during Sleep mode"]
-            #[inline]
-            pub fn sram2lpen(&self) -> SRAM2LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRAM2LPENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x7e67_91ff }
-            }
-            #[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 - IO port A clock enable during sleep mode"]
-            #[inline]
-            pub fn gpioalpen(&mut self) -> _GPIOALPENW {
-                _GPIOALPENW { w: self }
-            }
-            #[doc = "Bit 1 - IO port B clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpioblpen(&mut self) -> _GPIOBLPENW {
-                _GPIOBLPENW { w: self }
-            }
-            #[doc = "Bit 2 - IO port C clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpioclpen(&mut self) -> _GPIOCLPENW {
-                _GPIOCLPENW { w: self }
-            }
-            #[doc = "Bit 3 - IO port D clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpiodlpen(&mut self) -> _GPIODLPENW {
-                _GPIODLPENW { w: self }
-            }
-            #[doc = "Bit 4 - IO port E clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpioelpen(&mut self) -> _GPIOELPENW {
-                _GPIOELPENW { w: self }
-            }
-            #[doc = "Bit 5 - IO port F clock enable during sleep mode"]
-            #[inline]
-            pub fn gpioflpen(&mut self) -> _GPIOFLPENW {
-                _GPIOFLPENW { w: self }
-            }
-            #[doc = "Bit 6 - IO port G clock enable during sleep mode"]
-            #[inline]
-            pub fn gpioglpen(&mut self) -> _GPIOGLPENW {
-                _GPIOGLPENW { w: self }
-            }
-            #[doc = "Bit 7 - IO port H clock enable during Sleep mode"]
-            #[inline]
-            pub fn gpiohlpen(&mut self) -> _GPIOHLPENW {
-                _GPIOHLPENW { w: self }
-            }
-            #[doc = "Bit 12 - CRC clock enable during Sleep mode"]
-            #[inline]
-            pub fn crclpen(&mut self) -> _CRCLPENW {
-                _CRCLPENW { w: self }
-            }
-            #[doc = "Bit 15 - Flash interface clock enable during Sleep mode"]
-            #[inline]
-            pub fn flitflpen(&mut self) -> _FLITFLPENW {
-                _FLITFLPENW { w: self }
-            }
-            #[doc = "Bit 16 - SRAM 1interface clock enable during Sleep mode"]
-            #[inline]
-            pub fn sram1lpen(&mut self) -> _SRAM1LPENW {
-                _SRAM1LPENW { w: self }
-            }
-            #[doc = "Bit 21 - DMA1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn dma1lpen(&mut self) -> _DMA1LPENW {
-                _DMA1LPENW { w: self }
-            }
-            #[doc = "Bit 22 - DMA2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn dma2lpen(&mut self) -> _DMA2LPENW {
-                _DMA2LPENW { w: self }
-            }
-            #[doc = "Bit 17 - SRAM2interface clock enable during Sleep mode"]
-            #[inline]
-            pub fn sram2lpen(&mut self) -> _SRAM2LPENW {
-                _SRAM2LPENW { w: self }
-            }
-        }
-    }
-    #[doc = "AHB2 peripheral clock enable in low power mode register"]
-    pub struct AHB2LPENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AHB2 peripheral clock enable in low power mode register"]
-    pub mod ahb2lpenr {
-        #[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::AHB2LPENR {
-            #[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 = r" Value of the field"]
-        pub struct OTGFSLPENR {
-            bits: bool,
-        }
-        impl OTGFSLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RNGLPENR {
-            bits: bool,
-        }
-        impl RNGLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSMCLPENR {
-            bits: bool,
-        }
-        impl FSMCLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct QSPILPENR {
-            bits: bool,
-        }
-        impl QSPILPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OTGFSLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTGFSLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RNGLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RNGLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSMCLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSMCLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _QSPILPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _QSPILPENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - USB OTG FS clock enable during Sleep mode"]
-            #[inline]
-            pub fn otgfslpen(&self) -> OTGFSLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTGFSLPENR { bits }
-            }
-            #[doc = "Bit 6 - RNGLPEN"]
-            #[inline]
-            pub fn rnglpen(&self) -> RNGLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RNGLPENR { bits }
-            }
-            #[doc = "Bit 0 - Flexible memory controller module clock enable during Sleep mode"]
-            #[inline]
-            pub fn fsmclpen(&self) -> FSMCLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSMCLPENR { bits }
-            }
-            #[doc = "Bit 1 - QUADSPI memory controller module clock enable during Sleep mode"]
-            #[inline]
-            pub fn qspilpen(&self) -> QSPILPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                QSPILPENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xf1 }
-            }
-            #[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 7 - USB OTG FS clock enable during Sleep mode"]
-            #[inline]
-            pub fn otgfslpen(&mut self) -> _OTGFSLPENW {
-                _OTGFSLPENW { w: self }
-            }
-            #[doc = "Bit 6 - RNGLPEN"]
-            #[inline]
-            pub fn rnglpen(&mut self) -> _RNGLPENW {
-                _RNGLPENW { w: self }
-            }
-            #[doc = "Bit 0 - Flexible memory controller module clock enable during Sleep mode"]
-            #[inline]
-            pub fn fsmclpen(&mut self) -> _FSMCLPENW {
-                _FSMCLPENW { w: self }
-            }
-            #[doc = "Bit 1 - QUADSPI memory controller module clock enable during Sleep mode"]
-            #[inline]
-            pub fn qspilpen(&mut self) -> _QSPILPENW {
-                _QSPILPENW { w: self }
-            }
-        }
-    }
-    #[doc = "APB1 peripheral clock enable in low power mode register"]
-    pub struct APB1LPENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "APB1 peripheral clock enable in low power mode register"]
-    pub mod apb1lpenr {
-        #[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::APB1LPENR {
-            #[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 = r" Value of the field"]
-        pub struct TIM2LPENR {
-            bits: bool,
-        }
-        impl TIM2LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM3LPENR {
-            bits: bool,
-        }
-        impl TIM3LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM4LPENR {
-            bits: bool,
-        }
-        impl TIM4LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM5LPENR {
-            bits: bool,
-        }
-        impl TIM5LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM6LPENR {
-            bits: bool,
-        }
-        impl TIM6LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM7LPENR {
-            bits: bool,
-        }
-        impl TIM7LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM12LPENR {
-            bits: bool,
-        }
-        impl TIM12LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM13LPENR {
-            bits: bool,
-        }
-        impl TIM13LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM14LPENR {
-            bits: bool,
-        }
-        impl TIM14LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WWDGLPENR {
-            bits: bool,
-        }
-        impl WWDGLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI2LPENR {
-            bits: bool,
-        }
-        impl SPI2LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI3LPENR {
-            bits: bool,
-        }
-        impl SPI3LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART2LPENR {
-            bits: bool,
-        }
-        impl USART2LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART3LPENR {
-            bits: bool,
-        }
-        impl USART3LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C1LPENR {
-            bits: bool,
-        }
-        impl I2C1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C2LPENR {
-            bits: bool,
-        }
-        impl I2C2LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C3LPENR {
-            bits: bool,
-        }
-        impl I2C3LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C4LPENR {
-            bits: bool,
-        }
-        impl I2C4LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN1LPENR {
-            bits: bool,
-        }
-        impl CAN1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN2LPENR {
-            bits: bool,
-        }
-        impl CAN2LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWRLPENR {
-            bits: bool,
-        }
-        impl PWRLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LPTIMER1LPENR {
-            bits: bool,
-        }
-        impl LPTIMER1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTCAPBENR {
-            bits: bool,
-        }
-        impl RTCAPBENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART4LPENR {
-            bits: bool,
-        }
-        impl USART4LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART5LPENR {
-            bits: bool,
-        }
-        impl USART5LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAN3LPENR {
-            bits: bool,
-        }
-        impl CAN3LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DACLPENR {
-            bits: bool,
-        }
-        impl DACLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART7LPENR {
-            bits: bool,
-        }
-        impl UART7LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UART8LPENR {
-            bits: bool,
-        }
-        impl UART8LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIM2LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM2LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM3LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM3LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM4LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM4LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM5LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM5LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM6LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM6LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM7LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM7LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM12LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM12LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM13LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM13LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM14LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM14LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WWDGLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WWDGLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI2LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI2LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI3LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI3LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART2LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART2LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART3LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART3LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C2LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C2LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C3LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C3LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C4LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C4LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN2LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN2LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWRLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWRLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LPTIMER1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LPTIMER1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTCAPBENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTCAPBENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART4LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART4LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART5LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART5LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAN3LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN3LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DACLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART7LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART7LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UART8LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UART8LPENW<'a> {
-            #[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 - TIM2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim2lpen(&self) -> TIM2LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM2LPENR { bits }
-            }
-            #[doc = "Bit 1 - TIM3 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim3lpen(&self) -> TIM3LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM3LPENR { bits }
-            }
-            #[doc = "Bit 2 - TIM4 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim4lpen(&self) -> TIM4LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM4LPENR { bits }
-            }
-            #[doc = "Bit 3 - TIM5 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim5lpen(&self) -> TIM5LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM5LPENR { bits }
-            }
-            #[doc = "Bit 4 - TIM6LPEN"]
-            #[inline]
-            pub fn tim6lpen(&self) -> TIM6LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM6LPENR { bits }
-            }
-            #[doc = "Bit 5 - TIM7LPEN"]
-            #[inline]
-            pub fn tim7lpen(&self) -> TIM7LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM7LPENR { bits }
-            }
-            #[doc = "Bit 6 - TIM12LPEN"]
-            #[inline]
-            pub fn tim12lpen(&self) -> TIM12LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM12LPENR { bits }
-            }
-            #[doc = "Bit 7 - TIM13LPEN"]
-            #[inline]
-            pub fn tim13lpen(&self) -> TIM13LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM13LPENR { bits }
-            }
-            #[doc = "Bit 8 - TIM14LPEN"]
-            #[inline]
-            pub fn tim14lpen(&self) -> TIM14LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM14LPENR { bits }
-            }
-            #[doc = "Bit 11 - Window watchdog clock enable during Sleep mode"]
-            #[inline]
-            pub fn wwdglpen(&self) -> WWDGLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WWDGLPENR { bits }
-            }
-            #[doc = "Bit 14 - SPI2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi2lpen(&self) -> SPI2LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI2LPENR { bits }
-            }
-            #[doc = "Bit 15 - SPI3 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi3lpen(&self) -> SPI3LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI3LPENR { bits }
-            }
-            #[doc = "Bit 17 - USART2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart2lpen(&self) -> USART2LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART2LPENR { bits }
-            }
-            #[doc = "Bit 18 - USART3LPEN"]
-            #[inline]
-            pub fn usart3lpen(&self) -> USART3LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART3LPENR { bits }
-            }
-            #[doc = "Bit 21 - I2C1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn i2c1lpen(&self) -> I2C1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C1LPENR { bits }
-            }
-            #[doc = "Bit 22 - I2C2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn i2c2lpen(&self) -> I2C2LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C2LPENR { bits }
-            }
-            #[doc = "Bit 23 - I2C3 clock enable during Sleep mode"]
-            #[inline]
-            pub fn i2c3lpen(&self) -> I2C3LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C3LPENR { bits }
-            }
-            #[doc = "Bit 24 - I2C4LPEN"]
-            #[inline]
-            pub fn i2c4lpen(&self) -> I2C4LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C4LPENR { bits }
-            }
-            #[doc = "Bit 25 - CAN1LPEN"]
-            #[inline]
-            pub fn can1lpen(&self) -> CAN1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN1LPENR { bits }
-            }
-            #[doc = "Bit 26 - CAN2LPEN"]
-            #[inline]
-            pub fn can2lpen(&self) -> CAN2LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN2LPENR { bits }
-            }
-            #[doc = "Bit 28 - Power interface clock enable during Sleep mode"]
-            #[inline]
-            pub fn pwrlpen(&self) -> PWRLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PWRLPENR { bits }
-            }
-            #[doc = "Bit 9 - TIM14 clock enable during Sleep mode"]
-            #[inline]
-            pub fn lptimer1lpen(&self) -> LPTIMER1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LPTIMER1LPENR { bits }
-            }
-            #[doc = "Bit 10 - RTC APB clock enable during Sleep mode"]
-            #[inline]
-            pub fn rtcapben(&self) -> RTCAPBENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTCAPBENR { bits }
-            }
-            #[doc = "Bit 19 - USART4 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart4lpen(&self) -> USART4LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART4LPENR { bits }
-            }
-            #[doc = "Bit 20 - USART5 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart5lpen(&self) -> USART5LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART5LPENR { bits }
-            }
-            #[doc = "Bit 27 - CAN3 clock enable during Sleep mode"]
-            #[inline]
-            pub fn can3lpen(&self) -> CAN3LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAN3LPENR { bits }
-            }
-            #[doc = "Bit 29 - DAC clock enable during Sleep mode"]
-            #[inline]
-            pub fn daclpen(&self) -> DACLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DACLPENR { bits }
-            }
-            #[doc = "Bit 30 - UART7 clock enable during Sleep mode"]
-            #[inline]
-            pub fn uart7lpen(&self) -> UART7LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART7LPENR { bits }
-            }
-            #[doc = "Bit 31 - UART8 clock enable during Sleep mode"]
-            #[inline]
-            pub fn uart8lpen(&self) -> UART8LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UART8LPENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x36fe_c9ff }
-            }
-            #[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 - TIM2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim2lpen(&mut self) -> _TIM2LPENW {
-                _TIM2LPENW { w: self }
-            }
-            #[doc = "Bit 1 - TIM3 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim3lpen(&mut self) -> _TIM3LPENW {
-                _TIM3LPENW { w: self }
-            }
-            #[doc = "Bit 2 - TIM4 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim4lpen(&mut self) -> _TIM4LPENW {
-                _TIM4LPENW { w: self }
-            }
-            #[doc = "Bit 3 - TIM5 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim5lpen(&mut self) -> _TIM5LPENW {
-                _TIM5LPENW { w: self }
-            }
-            #[doc = "Bit 4 - TIM6LPEN"]
-            #[inline]
-            pub fn tim6lpen(&mut self) -> _TIM6LPENW {
-                _TIM6LPENW { w: self }
-            }
-            #[doc = "Bit 5 - TIM7LPEN"]
-            #[inline]
-            pub fn tim7lpen(&mut self) -> _TIM7LPENW {
-                _TIM7LPENW { w: self }
-            }
-            #[doc = "Bit 6 - TIM12LPEN"]
-            #[inline]
-            pub fn tim12lpen(&mut self) -> _TIM12LPENW {
-                _TIM12LPENW { w: self }
-            }
-            #[doc = "Bit 7 - TIM13LPEN"]
-            #[inline]
-            pub fn tim13lpen(&mut self) -> _TIM13LPENW {
-                _TIM13LPENW { w: self }
-            }
-            #[doc = "Bit 8 - TIM14LPEN"]
-            #[inline]
-            pub fn tim14lpen(&mut self) -> _TIM14LPENW {
-                _TIM14LPENW { w: self }
-            }
-            #[doc = "Bit 11 - Window watchdog clock enable during Sleep mode"]
-            #[inline]
-            pub fn wwdglpen(&mut self) -> _WWDGLPENW {
-                _WWDGLPENW { w: self }
-            }
-            #[doc = "Bit 14 - SPI2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi2lpen(&mut self) -> _SPI2LPENW {
-                _SPI2LPENW { w: self }
-            }
-            #[doc = "Bit 15 - SPI3 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi3lpen(&mut self) -> _SPI3LPENW {
-                _SPI3LPENW { w: self }
-            }
-            #[doc = "Bit 17 - USART2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart2lpen(&mut self) -> _USART2LPENW {
-                _USART2LPENW { w: self }
-            }
-            #[doc = "Bit 18 - USART3LPEN"]
-            #[inline]
-            pub fn usart3lpen(&mut self) -> _USART3LPENW {
-                _USART3LPENW { w: self }
-            }
-            #[doc = "Bit 21 - I2C1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn i2c1lpen(&mut self) -> _I2C1LPENW {
-                _I2C1LPENW { w: self }
-            }
-            #[doc = "Bit 22 - I2C2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn i2c2lpen(&mut self) -> _I2C2LPENW {
-                _I2C2LPENW { w: self }
-            }
-            #[doc = "Bit 23 - I2C3 clock enable during Sleep mode"]
-            #[inline]
-            pub fn i2c3lpen(&mut self) -> _I2C3LPENW {
-                _I2C3LPENW { w: self }
-            }
-            #[doc = "Bit 24 - I2C4LPEN"]
-            #[inline]
-            pub fn i2c4lpen(&mut self) -> _I2C4LPENW {
-                _I2C4LPENW { w: self }
-            }
-            #[doc = "Bit 25 - CAN1LPEN"]
-            #[inline]
-            pub fn can1lpen(&mut self) -> _CAN1LPENW {
-                _CAN1LPENW { w: self }
-            }
-            #[doc = "Bit 26 - CAN2LPEN"]
-            #[inline]
-            pub fn can2lpen(&mut self) -> _CAN2LPENW {
-                _CAN2LPENW { w: self }
-            }
-            #[doc = "Bit 28 - Power interface clock enable during Sleep mode"]
-            #[inline]
-            pub fn pwrlpen(&mut self) -> _PWRLPENW {
-                _PWRLPENW { w: self }
-            }
-            #[doc = "Bit 9 - TIM14 clock enable during Sleep mode"]
-            #[inline]
-            pub fn lptimer1lpen(&mut self) -> _LPTIMER1LPENW {
-                _LPTIMER1LPENW { w: self }
-            }
-            #[doc = "Bit 10 - RTC APB clock enable during Sleep mode"]
-            #[inline]
-            pub fn rtcapben(&mut self) -> _RTCAPBENW {
-                _RTCAPBENW { w: self }
-            }
-            #[doc = "Bit 19 - USART4 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart4lpen(&mut self) -> _USART4LPENW {
-                _USART4LPENW { w: self }
-            }
-            #[doc = "Bit 20 - USART5 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart5lpen(&mut self) -> _USART5LPENW {
-                _USART5LPENW { w: self }
-            }
-            #[doc = "Bit 27 - CAN3 clock enable during Sleep mode"]
-            #[inline]
-            pub fn can3lpen(&mut self) -> _CAN3LPENW {
-                _CAN3LPENW { w: self }
-            }
-            #[doc = "Bit 29 - DAC clock enable during Sleep mode"]
-            #[inline]
-            pub fn daclpen(&mut self) -> _DACLPENW {
-                _DACLPENW { w: self }
-            }
-            #[doc = "Bit 30 - UART7 clock enable during Sleep mode"]
-            #[inline]
-            pub fn uart7lpen(&mut self) -> _UART7LPENW {
-                _UART7LPENW { w: self }
-            }
-            #[doc = "Bit 31 - UART8 clock enable during Sleep mode"]
-            #[inline]
-            pub fn uart8lpen(&mut self) -> _UART8LPENW {
-                _UART8LPENW { w: self }
-            }
-        }
-    }
-    #[doc = "APB2 peripheral clock enabled in low power mode register"]
-    pub struct APB2LPENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "APB2 peripheral clock enabled in low power mode register"]
-    pub mod apb2lpenr {
-        #[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::APB2LPENR {
-            #[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 = r" Value of the field"]
-        pub struct TIM1LPENR {
-            bits: bool,
-        }
-        impl TIM1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM8LPENR {
-            bits: bool,
-        }
-        impl TIM8LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART1LPENR {
-            bits: bool,
-        }
-        impl USART1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART6LPENR {
-            bits: bool,
-        }
-        impl USART6LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADC1LPENR {
-            bits: bool,
-        }
-        impl ADC1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDIOLPENR {
-            bits: bool,
-        }
-        impl SDIOLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI1LPENR {
-            bits: bool,
-        }
-        impl SPI1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI4LPENR {
-            bits: bool,
-        }
-        impl SPI4LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SYSCFGLPENR {
-            bits: bool,
-        }
-        impl SYSCFGLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM9LPENR {
-            bits: bool,
-        }
-        impl TIM9LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM10LPENR {
-            bits: bool,
-        }
-        impl TIM10LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIM11LPENR {
-            bits: bool,
-        }
-        impl TIM11LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFSDMLPENR {
-            bits: bool,
-        }
-        impl DFSDMLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART9LPENR {
-            bits: bool,
-        }
-        impl USART9LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USART10LPENR {
-            bits: bool,
-        }
-        impl USART10LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EXTITENR {
-            bits: bool,
-        }
-        impl EXTITENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPI5LPENR {
-            bits: bool,
-        }
-        impl SPI5LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SAI1LPENR {
-            bits: bool,
-        }
-        impl SAI1LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFSDM2LPENR {
-            bits: bool,
-        }
-        impl DFSDM2LPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIM1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM8LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM8LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART6LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART6LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADC1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADC1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDIOLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDIOLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI4LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI4LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SYSCFGLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SYSCFGLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM9LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM9LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM10LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM10LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIM11LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIM11LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFSDMLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFSDMLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART9LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART9LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USART10LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USART10LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EXTITENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTITENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPI5LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPI5LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SAI1LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SAI1LPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFSDM2LPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFSDM2LPENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - TIM1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim1lpen(&self) -> TIM1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM1LPENR { bits }
-            }
-            #[doc = "Bit 1 - TIM8LPEN"]
-            #[inline]
-            pub fn tim8lpen(&self) -> TIM8LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM8LPENR { bits }
-            }
-            #[doc = "Bit 4 - USART1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart1lpen(&self) -> USART1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART1LPENR { bits }
-            }
-            #[doc = "Bit 5 - USART6 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart6lpen(&self) -> USART6LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART6LPENR { bits }
-            }
-            #[doc = "Bit 8 - ADC1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn adc1lpen(&self) -> ADC1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADC1LPENR { bits }
-            }
-            #[doc = "Bit 11 - SDIO clock enable during Sleep mode"]
-            #[inline]
-            pub fn sdiolpen(&self) -> SDIOLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDIOLPENR { bits }
-            }
-            #[doc = "Bit 12 - SPI 1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi1lpen(&self) -> SPI1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI1LPENR { bits }
-            }
-            #[doc = "Bit 13 - SPI4 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi4lpen(&self) -> SPI4LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI4LPENR { bits }
-            }
-            #[doc = "Bit 14 - System configuration controller clock enable during Sleep mode"]
-            #[inline]
-            pub fn syscfglpen(&self) -> SYSCFGLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SYSCFGLPENR { bits }
-            }
-            #[doc = "Bit 16 - TIM9 clock enable during sleep mode"]
-            #[inline]
-            pub fn tim9lpen(&self) -> TIM9LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM9LPENR { bits }
-            }
-            #[doc = "Bit 17 - TIM10 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim10lpen(&self) -> TIM10LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM10LPENR { bits }
-            }
-            #[doc = "Bit 18 - TIM11 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim11lpen(&self) -> TIM11LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIM11LPENR { bits }
-            }
-            #[doc = "Bit 24 - DFSDMLPEN"]
-            #[inline]
-            pub fn dfsdmlpen(&self) -> DFSDMLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFSDMLPENR { bits }
-            }
-            #[doc = "Bit 6 - USART9 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart9lpen(&self) -> USART9LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART9LPENR { bits }
-            }
-            #[doc = "Bit 7 - USART10 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart10lpen(&self) -> USART10LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USART10LPENR { bits }
-            }
-            #[doc = "Bit 15 - EXTIT APB and SYSCTRL PFREE clock enable during Sleep mode"]
-            #[inline]
-            pub fn extiten(&self) -> EXTITENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EXTITENR { bits }
-            }
-            #[doc = "Bit 20 - SPI5 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi5lpen(&self) -> SPI5LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPI5LPENR { bits }
-            }
-            #[doc = "Bit 22 - SAI1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn sai1lpen(&self) -> SAI1LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SAI1LPENR { bits }
-            }
-            #[doc = "Bit 25 - DFSDM2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn dfsdm2lpen(&self) -> DFSDM2LPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFSDM2LPENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0007_5f33 }
-            }
-            #[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 - TIM1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim1lpen(&mut self) -> _TIM1LPENW {
-                _TIM1LPENW { w: self }
-            }
-            #[doc = "Bit 1 - TIM8LPEN"]
-            #[inline]
-            pub fn tim8lpen(&mut self) -> _TIM8LPENW {
-                _TIM8LPENW { w: self }
-            }
-            #[doc = "Bit 4 - USART1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart1lpen(&mut self) -> _USART1LPENW {
-                _USART1LPENW { w: self }
-            }
-            #[doc = "Bit 5 - USART6 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart6lpen(&mut self) -> _USART6LPENW {
-                _USART6LPENW { w: self }
-            }
-            #[doc = "Bit 8 - ADC1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn adc1lpen(&mut self) -> _ADC1LPENW {
-                _ADC1LPENW { w: self }
-            }
-            #[doc = "Bit 11 - SDIO clock enable during Sleep mode"]
-            #[inline]
-            pub fn sdiolpen(&mut self) -> _SDIOLPENW {
-                _SDIOLPENW { w: self }
-            }
-            #[doc = "Bit 12 - SPI 1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi1lpen(&mut self) -> _SPI1LPENW {
-                _SPI1LPENW { w: self }
-            }
-            #[doc = "Bit 13 - SPI4 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi4lpen(&mut self) -> _SPI4LPENW {
-                _SPI4LPENW { w: self }
-            }
-            #[doc = "Bit 14 - System configuration controller clock enable during Sleep mode"]
-            #[inline]
-            pub fn syscfglpen(&mut self) -> _SYSCFGLPENW {
-                _SYSCFGLPENW { w: self }
-            }
-            #[doc = "Bit 16 - TIM9 clock enable during sleep mode"]
-            #[inline]
-            pub fn tim9lpen(&mut self) -> _TIM9LPENW {
-                _TIM9LPENW { w: self }
-            }
-            #[doc = "Bit 17 - TIM10 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim10lpen(&mut self) -> _TIM10LPENW {
-                _TIM10LPENW { w: self }
-            }
-            #[doc = "Bit 18 - TIM11 clock enable during Sleep mode"]
-            #[inline]
-            pub fn tim11lpen(&mut self) -> _TIM11LPENW {
-                _TIM11LPENW { w: self }
-            }
-            #[doc = "Bit 24 - DFSDMLPEN"]
-            #[inline]
-            pub fn dfsdmlpen(&mut self) -> _DFSDMLPENW {
-                _DFSDMLPENW { w: self }
-            }
-            #[doc = "Bit 6 - USART9 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart9lpen(&mut self) -> _USART9LPENW {
-                _USART9LPENW { w: self }
-            }
-            #[doc = "Bit 7 - USART10 clock enable during Sleep mode"]
-            #[inline]
-            pub fn usart10lpen(&mut self) -> _USART10LPENW {
-                _USART10LPENW { w: self }
-            }
-            #[doc = "Bit 15 - EXTIT APB and SYSCTRL PFREE clock enable during Sleep mode"]
-            #[inline]
-            pub fn extiten(&mut self) -> _EXTITENW {
-                _EXTITENW { w: self }
-            }
-            #[doc = "Bit 20 - SPI5 clock enable during Sleep mode"]
-            #[inline]
-            pub fn spi5lpen(&mut self) -> _SPI5LPENW {
-                _SPI5LPENW { w: self }
-            }
-            #[doc = "Bit 22 - SAI1 clock enable during Sleep mode"]
-            #[inline]
-            pub fn sai1lpen(&mut self) -> _SAI1LPENW {
-                _SAI1LPENW { w: self }
-            }
-            #[doc = "Bit 25 - DFSDM2 clock enable during Sleep mode"]
-            #[inline]
-            pub fn dfsdm2lpen(&mut self) -> _DFSDM2LPENW {
-                _DFSDM2LPENW { w: self }
-            }
-        }
-    }
-    #[doc = "Backup domain control register"]
-    pub struct BDCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Backup domain control register"]
-    pub mod bdcr {
-        #[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::BDCR {
-            #[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 = r" Value of the field"]
-        pub struct BDRSTR {
-            bits: bool,
-        }
-        impl BDRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTCENR {
-            bits: bool,
-        }
-        impl RTCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTCSEL1R {
-            bits: bool,
-        }
-        impl RTCSEL1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTCSEL0R {
-            bits: bool,
-        }
-        impl RTCSEL0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSEBYPR {
-            bits: bool,
-        }
-        impl LSEBYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSERDYR {
-            bits: bool,
-        }
-        impl LSERDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSEONR {
-            bits: bool,
-        }
-        impl LSEONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSEMODR {
-            bits: bool,
-        }
-        impl LSEMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _BDRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BDRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTCSEL1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTCSEL1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTCSEL0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTCSEL0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSEBYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSEBYPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSEONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSEONW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSEMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSEMODW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 16 - Backup domain software reset"]
-            #[inline]
-            pub fn bdrst(&self) -> BDRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BDRSTR { bits }
-            }
-            #[doc = "Bit 15 - RTC clock enable"]
-            #[inline]
-            pub fn rtcen(&self) -> RTCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTCENR { bits }
-            }
-            #[doc = "Bit 9 - RTC clock source selection"]
-            #[inline]
-            pub fn rtcsel1(&self) -> RTCSEL1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTCSEL1R { bits }
-            }
-            #[doc = "Bit 8 - RTC clock source selection"]
-            #[inline]
-            pub fn rtcsel0(&self) -> RTCSEL0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTCSEL0R { bits }
-            }
-            #[doc = "Bit 2 - External low-speed oscillator bypass"]
-            #[inline]
-            pub fn lsebyp(&self) -> LSEBYPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSEBYPR { bits }
-            }
-            #[doc = "Bit 1 - External low-speed oscillator ready"]
-            #[inline]
-            pub fn lserdy(&self) -> LSERDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSERDYR { bits }
-            }
-            #[doc = "Bit 0 - External low-speed oscillator enable"]
-            #[inline]
-            pub fn lseon(&self) -> LSEONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSEONR { bits }
-            }
-            #[doc = "Bit 3 - External low-speed oscillator bypass"]
-            #[inline]
-            pub fn lsemod(&self) -> LSEMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSEMODR { bits }
-            }
-        }
-        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 16 - Backup domain software reset"]
-            #[inline]
-            pub fn bdrst(&mut self) -> _BDRSTW {
-                _BDRSTW { w: self }
-            }
-            #[doc = "Bit 15 - RTC clock enable"]
-            #[inline]
-            pub fn rtcen(&mut self) -> _RTCENW {
-                _RTCENW { w: self }
-            }
-            #[doc = "Bit 9 - RTC clock source selection"]
-            #[inline]
-            pub fn rtcsel1(&mut self) -> _RTCSEL1W {
-                _RTCSEL1W { w: self }
-            }
-            #[doc = "Bit 8 - RTC clock source selection"]
-            #[inline]
-            pub fn rtcsel0(&mut self) -> _RTCSEL0W {
-                _RTCSEL0W { w: self }
-            }
-            #[doc = "Bit 2 - External low-speed oscillator bypass"]
-            #[inline]
-            pub fn lsebyp(&mut self) -> _LSEBYPW {
-                _LSEBYPW { w: self }
-            }
-            #[doc = "Bit 0 - External low-speed oscillator enable"]
-            #[inline]
-            pub fn lseon(&mut self) -> _LSEONW {
-                _LSEONW { w: self }
-            }
-            #[doc = "Bit 3 - External low-speed oscillator bypass"]
-            #[inline]
-            pub fn lsemod(&mut self) -> _LSEMODW {
-                _LSEMODW { w: self }
-            }
-        }
-    }
-    #[doc = "clock control & status register"]
-    pub struct CSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "clock control & status register"]
-    pub mod csr {
-        #[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::CSR {
-            #[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 = r" Value of the field"]
-        pub struct LPWRRSTFR {
-            bits: bool,
-        }
-        impl LPWRRSTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WWDGRSTFR {
-            bits: bool,
-        }
-        impl WWDGRSTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WDGRSTFR {
-            bits: bool,
-        }
-        impl WDGRSTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SFTRSTFR {
-            bits: bool,
-        }
-        impl SFTRSTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PORRSTFR {
-            bits: bool,
-        }
-        impl PORRSTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PADRSTFR {
-            bits: bool,
-        }
-        impl PADRSTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BORRSTFR {
-            bits: bool,
-        }
-        impl BORRSTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RMVFR {
-            bits: bool,
-        }
-        impl RMVFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSIRDYR {
-            bits: bool,
-        }
-        impl LSIRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSIONR {
-            bits: bool,
-        }
-        impl LSIONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LPWRRSTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LPWRRSTFW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WWDGRSTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WWDGRSTFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WDGRSTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDGRSTFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SFTRSTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SFTRSTFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PORRSTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PORRSTFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PADRSTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PADRSTFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BORRSTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BORRSTFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RMVFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RMVFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSIONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSIONW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 31 - Low-power reset flag"]
-            #[inline]
-            pub fn lpwrrstf(&self) -> LPWRRSTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LPWRRSTFR { bits }
-            }
-            #[doc = "Bit 30 - Window watchdog reset flag"]
-            #[inline]
-            pub fn wwdgrstf(&self) -> WWDGRSTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WWDGRSTFR { bits }
-            }
-            #[doc = "Bit 29 - Independent watchdog reset flag"]
-            #[inline]
-            pub fn wdgrstf(&self) -> WDGRSTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WDGRSTFR { bits }
-            }
-            #[doc = "Bit 28 - Software reset flag"]
-            #[inline]
-            pub fn sftrstf(&self) -> SFTRSTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SFTRSTFR { bits }
-            }
-            #[doc = "Bit 27 - POR/PDR reset flag"]
-            #[inline]
-            pub fn porrstf(&self) -> PORRSTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PORRSTFR { bits }
-            }
-            #[doc = "Bit 26 - PIN reset flag"]
-            #[inline]
-            pub fn padrstf(&self) -> PADRSTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PADRSTFR { bits }
-            }
-            #[doc = "Bit 25 - BOR reset flag"]
-            #[inline]
-            pub fn borrstf(&self) -> BORRSTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BORRSTFR { bits }
-            }
-            #[doc = "Bit 24 - Remove reset flag"]
-            #[inline]
-            pub fn rmvf(&self) -> RMVFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RMVFR { bits }
-            }
-            #[doc = "Bit 1 - Internal low-speed oscillator ready"]
-            #[inline]
-            pub fn lsirdy(&self) -> LSIRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSIRDYR { bits }
-            }
-            #[doc = "Bit 0 - Internal low-speed oscillator enable"]
-            #[inline]
-            pub fn lsion(&self) -> LSIONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSIONR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0e00_0000 }
-            }
-            #[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 31 - Low-power reset flag"]
-            #[inline]
-            pub fn lpwrrstf(&mut self) -> _LPWRRSTFW {
-                _LPWRRSTFW { w: self }
-            }
-            #[doc = "Bit 30 - Window watchdog reset flag"]
-            #[inline]
-            pub fn wwdgrstf(&mut self) -> _WWDGRSTFW {
-                _WWDGRSTFW { w: self }
-            }
-            #[doc = "Bit 29 - Independent watchdog reset flag"]
-            #[inline]
-            pub fn wdgrstf(&mut self) -> _WDGRSTFW {
-                _WDGRSTFW { w: self }
-            }
-            #[doc = "Bit 28 - Software reset flag"]
-            #[inline]
-            pub fn sftrstf(&mut self) -> _SFTRSTFW {
-                _SFTRSTFW { w: self }
-            }
-            #[doc = "Bit 27 - POR/PDR reset flag"]
-            #[inline]
-            pub fn porrstf(&mut self) -> _PORRSTFW {
-                _PORRSTFW { w: self }
-            }
-            #[doc = "Bit 26 - PIN reset flag"]
-            #[inline]
-            pub fn padrstf(&mut self) -> _PADRSTFW {
-                _PADRSTFW { w: self }
-            }
-            #[doc = "Bit 25 - BOR reset flag"]
-            #[inline]
-            pub fn borrstf(&mut self) -> _BORRSTFW {
-                _BORRSTFW { w: self }
-            }
-            #[doc = "Bit 24 - Remove reset flag"]
-            #[inline]
-            pub fn rmvf(&mut self) -> _RMVFW {
-                _RMVFW { w: self }
-            }
-            #[doc = "Bit 0 - Internal low-speed oscillator enable"]
-            #[inline]
-            pub fn lsion(&mut self) -> _LSIONW {
-                _LSIONW { w: self }
-            }
-        }
-    }
-    #[doc = "spread spectrum clock generation register"]
-    pub struct SSCGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "spread spectrum clock generation register"]
-    pub mod sscgr {
-        #[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::SSCGR {
-            #[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 = r" Value of the field"]
-        pub struct SSCGENR {
-            bits: bool,
-        }
-        impl SSCGENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPREADSELR {
-            bits: bool,
-        }
-        impl SPREADSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INCSTEPR {
-            bits: u16,
-        }
-        impl INCSTEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODPERR {
-            bits: u16,
-        }
-        impl MODPERR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SSCGENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SSCGENW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SPREADSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPREADSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _INCSTEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INCSTEPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x7fff;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODPERW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODPERW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x1fff;
-                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 = "Bit 31 - Spread spectrum modulation enable"]
-            #[inline]
-            pub fn sscgen(&self) -> SSCGENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SSCGENR { bits }
-            }
-            #[doc = "Bit 30 - Spread Select"]
-            #[inline]
-            pub fn spreadsel(&self) -> SPREADSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPREADSELR { bits }
-            }
-            #[doc = "Bits 13:27 - Incrementation step"]
-            #[inline]
-            pub fn incstep(&self) -> INCSTEPR {
-                let bits = {
-                    const MASK: u16 = 0x7fff;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INCSTEPR { bits }
-            }
-            #[doc = "Bits 0:12 - Modulation period"]
-            #[inline]
-            pub fn modper(&self) -> MODPERR {
-                let bits = {
-                    const MASK: u16 = 0x1fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MODPERR { bits }
-            }
-        }
-        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 31 - Spread spectrum modulation enable"]
-            #[inline]
-            pub fn sscgen(&mut self) -> _SSCGENW {
-                _SSCGENW { w: self }
-            }
-            #[doc = "Bit 30 - Spread Select"]
-            #[inline]
-            pub fn spreadsel(&mut self) -> _SPREADSELW {
-                _SPREADSELW { w: self }
-            }
-            #[doc = "Bits 13:27 - Incrementation step"]
-            #[inline]
-            pub fn incstep(&mut self) -> _INCSTEPW {
-                _INCSTEPW { w: self }
-            }
-            #[doc = "Bits 0:12 - Modulation period"]
-            #[inline]
-            pub fn modper(&mut self) -> _MODPERW {
-                _MODPERW { w: self }
-            }
-        }
-    }
-    #[doc = "PLLI2S configuration register"]
-    pub struct PLLI2SCFGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "PLLI2S configuration register"]
-    pub mod plli2scfgr {
-        #[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::PLLI2SCFGR {
-            #[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 = r" Value of the field"]
-        pub struct PLLI2SRR {
-            bits: u8,
-        }
-        impl PLLI2SRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PLLI2SNR {
-            bits: u16,
-        }
-        impl PLLI2SNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PLLI2SMR {
-            bits: u8,
-        }
-        impl PLLI2SMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PLLI2SSRCR {
-            bits: bool,
-        }
-        impl PLLI2SSRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLLI2SQR {
-            bits: u8,
-        }
-        impl PLLI2SQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PLLI2SRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PLLI2SNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SNW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x01ff;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PLLI2SMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x3f;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PLLI2SSRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SSRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLLI2SQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLLI2SQW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                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 28:30 - PLLI2S division factor for I2S clocks"]
-            #[inline]
-            pub fn plli2sr(&self) -> PLLI2SRR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLLI2SRR { bits }
-            }
-            #[doc = "Bits 6:14 - PLLI2S multiplication factor for VCO"]
-            #[inline]
-            pub fn plli2sn(&self) -> PLLI2SNR {
-                let bits = {
-                    const MASK: u16 = 0x01ff;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PLLI2SNR { bits }
-            }
-            # [ doc = "Bits 0:5 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn plli2sm(&self) -> PLLI2SMR {
-                let bits = {
-                    const MASK: u8 = 0x3f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLLI2SMR { bits }
-            }
-            #[doc = "Bit 22 - PLLI2S entry clock source"]
-            #[inline]
-            pub fn plli2ssrc(&self) -> PLLI2SSRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PLLI2SSRCR { bits }
-            }
-            #[doc = "Bits 24:27 - PLLI2S division factor for USB OTG FS/SDIO/RNG clock"]
-            #[inline]
-            pub fn plli2sq(&self) -> PLLI2SQR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLLI2SQR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x2000_3000 }
-            }
-            #[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 28:30 - PLLI2S division factor for I2S clocks"]
-            #[inline]
-            pub fn plli2sr(&mut self) -> _PLLI2SRW {
-                _PLLI2SRW { w: self }
-            }
-            #[doc = "Bits 6:14 - PLLI2S multiplication factor for VCO"]
-            #[inline]
-            pub fn plli2sn(&mut self) -> _PLLI2SNW {
-                _PLLI2SNW { w: self }
-            }
-            # [ doc = "Bits 0:5 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock" ] # [ inline ]
-            pub fn plli2sm(&mut self) -> _PLLI2SMW {
-                _PLLI2SMW { w: self }
-            }
-            #[doc = "Bit 22 - PLLI2S entry clock source"]
-            #[inline]
-            pub fn plli2ssrc(&mut self) -> _PLLI2SSRCW {
-                _PLLI2SSRCW { w: self }
-            }
-            #[doc = "Bits 24:27 - PLLI2S division factor for USB OTG FS/SDIO/RNG clock"]
-            #[inline]
-            pub fn plli2sq(&mut self) -> _PLLI2SQW {
-                _PLLI2SQW { w: self }
-            }
-        }
-    }
-    #[doc = "peripheral reset register"]
-    pub struct AHB3RSTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "peripheral reset register"]
-    pub mod ahb3rstr {
-        #[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::AHB3RSTR {
-            #[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 = r" Value of the field"]
-        pub struct FSMCRSTR {
-            bits: bool,
-        }
-        impl FSMCRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct QSPIRSTR {
-            bits: bool,
-        }
-        impl QSPIRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FSMCRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSMCRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _QSPIRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _QSPIRSTW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Flexible memory controller module reset"]
-            #[inline]
-            pub fn fsmcrst(&self) -> FSMCRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSMCRSTR { bits }
-            }
-            #[doc = "Bit 1 - QUADSPI module reset"]
-            #[inline]
-            pub fn qspirst(&self) -> QSPIRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                QSPIRSTR { bits }
-            }
-        }
-        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 - Flexible memory controller module reset"]
-            #[inline]
-            pub fn fsmcrst(&mut self) -> _FSMCRSTW {
-                _FSMCRSTW { w: self }
-            }
-            #[doc = "Bit 1 - QUADSPI module reset"]
-            #[inline]
-            pub fn qspirst(&mut self) -> _QSPIRSTW {
-                _QSPIRSTW { w: self }
-            }
-        }
-    }
-    #[doc = "AHB3 peripheral clock enable register"]
-    pub struct AHB3ENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AHB3 peripheral clock enable register"]
-    pub mod ahb3enr {
-        #[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::AHB3ENR {
-            #[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 = r" Value of the field"]
-        pub struct FSMCENR {
-            bits: bool,
-        }
-        impl FSMCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct QSPIENR {
-            bits: bool,
-        }
-        impl QSPIENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FSMCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSMCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _QSPIENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _QSPIENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Flexible memory controller module clock enable"]
-            #[inline]
-            pub fn fsmcen(&self) -> FSMCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSMCENR { bits }
-            }
-            #[doc = "Bit 1 - QUADSPI memory controller module clock enable"]
-            #[inline]
-            pub fn qspien(&self) -> QSPIENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                QSPIENR { bits }
-            }
-        }
-        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 - Flexible memory controller module clock enable"]
-            #[inline]
-            pub fn fsmcen(&mut self) -> _FSMCENW {
-                _FSMCENW { w: self }
-            }
-            #[doc = "Bit 1 - QUADSPI memory controller module clock enable"]
-            #[inline]
-            pub fn qspien(&mut self) -> _QSPIENW {
-                _QSPIENW { w: self }
-            }
-        }
-    }
-    #[doc = "AHB3 peripheral clock enable in low power mode register"]
-    pub struct AHB3LPENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AHB3 peripheral clock enable in low power mode register"]
-    pub mod ahb3lpenr {
-        #[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::AHB3LPENR {
-            #[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 = r" Value of the field"]
-        pub struct FSMCLPENR {
-            bits: bool,
-        }
-        impl FSMCLPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct QSPILPENR {
-            bits: bool,
-        }
-        impl QSPILPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FSMCLPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSMCLPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _QSPILPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _QSPILPENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Flexible memory controller module clock enable during Sleep mode"]
-            #[inline]
-            pub fn fsmclpen(&self) -> FSMCLPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSMCLPENR { bits }
-            }
-            #[doc = "Bit 1 - QUADSPI memory controller module clock enable during Sleep mode"]
-            #[inline]
-            pub fn qspilpen(&self) -> QSPILPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                QSPILPENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x03 }
-            }
-            #[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 - Flexible memory controller module clock enable during Sleep mode"]
-            #[inline]
-            pub fn fsmclpen(&mut self) -> _FSMCLPENW {
-                _FSMCLPENW { w: self }
-            }
-            #[doc = "Bit 1 - QUADSPI memory controller module clock enable during Sleep mode"]
-            #[inline]
-            pub fn qspilpen(&mut self) -> _QSPILPENW {
-                _QSPILPENW { w: self }
-            }
-        }
-    }
-    #[doc = "Dedicated Clocks Configuration Register"]
-    pub struct DCKCFGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Dedicated Clocks Configuration Register"]
-    pub mod dckcfgr {
-        #[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::DCKCFGR {
-            #[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 = r" Value of the field"]
-        pub struct CKDFSDM1ASELR {
-            bits: bool,
-        }
-        impl CKDFSDM1ASELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIMPRER {
-            bits: bool,
-        }
-        impl TIMPRER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2S1SRCR {
-            bits: u8,
-        }
-        impl I2S1SRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct I2S2SRCR {
-            bits: u8,
-        }
-        impl I2S2SRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct LPTIMER1SELR {
-            bits: u8,
-        }
-        impl LPTIMER1SELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKDFSDM1ASELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDFSDM1ASELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIMPREW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMPREW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2S1SRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2S1SRCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _I2S2SRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2S2SRCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 27;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _LPTIMER1SELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LPTIMER1SELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                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 15 - DFSDM1 audio clock selection."]
-            #[inline]
-            pub fn ckdfsdm1asel(&self) -> CKDFSDM1ASELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKDFSDM1ASELR { bits }
-            }
-            #[doc = "Bit 24 - Timers clocks prescalers selection"]
-            #[inline]
-            pub fn timpre(&self) -> TIMPRER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIMPRER { bits }
-            }
-            #[doc = "Bits 25:26 - I2S APB1 clocks source selection (I2S2/3)"]
-            #[inline]
-            pub fn i2s1src(&self) -> I2S1SRCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                I2S1SRCR { bits }
-            }
-            #[doc = "Bits 27:28 - I2S APB2 clocks source selection (I2S1/4/5)"]
-            #[inline]
-            pub fn i2s2src(&self) -> I2S2SRCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                I2S2SRCR { bits }
-            }
-            #[doc = "Bits 30:31 - LPTIMER1 kernel clock selection."]
-            #[inline]
-            pub fn lptimer1sel(&self) -> LPTIMER1SELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                LPTIMER1SELR { bits }
-            }
-        }
-        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 15 - DFSDM1 audio clock selection."]
-            #[inline]
-            pub fn ckdfsdm1asel(&mut self) -> _CKDFSDM1ASELW {
-                _CKDFSDM1ASELW { w: self }
-            }
-            #[doc = "Bit 24 - Timers clocks prescalers selection"]
-            #[inline]
-            pub fn timpre(&mut self) -> _TIMPREW {
-                _TIMPREW { w: self }
-            }
-            #[doc = "Bits 25:26 - I2S APB1 clocks source selection (I2S2/3)"]
-            #[inline]
-            pub fn i2s1src(&mut self) -> _I2S1SRCW {
-                _I2S1SRCW { w: self }
-            }
-            #[doc = "Bits 27:28 - I2S APB2 clocks source selection (I2S1/4/5)"]
-            #[inline]
-            pub fn i2s2src(&mut self) -> _I2S2SRCW {
-                _I2S2SRCW { w: self }
-            }
-            #[doc = "Bits 30:31 - LPTIMER1 kernel clock selection."]
-            #[inline]
-            pub fn lptimer1sel(&mut self) -> _LPTIMER1SELW {
-                _LPTIMER1SELW { w: self }
-            }
-        }
-    }
-    #[doc = "RCC clocks gated enable register"]
-    pub struct CKGATENR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "RCC clocks gated enable register"]
-    pub mod ckgatenr {
-        #[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::CKGATENR {
-            #[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 = r" Value of the field"]
-        pub struct AHB2APB1_CKENR {
-            bits: bool,
-        }
-        impl AHB2APB1_CKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AHB2APB2_CKENR {
-            bits: bool,
-        }
-        impl AHB2APB2_CKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CM4DBG_CKENR {
-            bits: bool,
-        }
-        impl CM4DBG_CKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPARE_CKENR {
-            bits: bool,
-        }
-        impl SPARE_CKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SRAM_CKENR {
-            bits: bool,
-        }
-        impl SRAM_CKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FLITF_CKENR {
-            bits: bool,
-        }
-        impl FLITF_CKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCC_CKENR {
-            bits: bool,
-        }
-        impl RCC_CKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EVTCL_CKENR {
-            bits: bool,
-        }
-        impl EVTCL_CKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AHB2APB1_CKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AHB2APB1_CKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AHB2APB2_CKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AHB2APB2_CKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CM4DBG_CKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CM4DBG_CKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPARE_CKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPARE_CKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SRAM_CKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SRAM_CKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FLITF_CKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FLITF_CKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCC_CKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCC_CKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EVTCL_CKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EVTCL_CKENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - AHB to APB1 Bridge clock enable"]
-            #[inline]
-            pub fn ahb2apb1_cken(&self) -> AHB2APB1_CKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AHB2APB1_CKENR { bits }
-            }
-            #[doc = "Bit 1 - AHB to APB2 Bridge clock enable"]
-            #[inline]
-            pub fn ahb2apb2_cken(&self) -> AHB2APB2_CKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AHB2APB2_CKENR { bits }
-            }
-            #[doc = "Bit 2 - Cortex M4 ETM clock enable"]
-            #[inline]
-            pub fn cm4dbg_cken(&self) -> CM4DBG_CKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CM4DBG_CKENR { bits }
-            }
-            #[doc = "Bit 3 - Spare clock enable"]
-            #[inline]
-            pub fn spare_cken(&self) -> SPARE_CKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPARE_CKENR { bits }
-            }
-            #[doc = "Bit 4 - SRQAM controller clock enable"]
-            #[inline]
-            pub fn sram_cken(&self) -> SRAM_CKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRAM_CKENR { bits }
-            }
-            #[doc = "Bit 5 - Flash Interface clock enable"]
-            #[inline]
-            pub fn flitf_cken(&self) -> FLITF_CKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FLITF_CKENR { bits }
-            }
-            #[doc = "Bit 6 - RCC clock enable"]
-            #[inline]
-            pub fn rcc_cken(&self) -> RCC_CKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCC_CKENR { bits }
-            }
-            #[doc = "Bit 7 - EVTCL_CKEN"]
-            #[inline]
-            pub fn evtcl_cken(&self) -> EVTCL_CKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EVTCL_CKENR { bits }
-            }
-        }
-        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 - AHB to APB1 Bridge clock enable"]
-            #[inline]
-            pub fn ahb2apb1_cken(&mut self) -> _AHB2APB1_CKENW {
-                _AHB2APB1_CKENW { w: self }
-            }
-            #[doc = "Bit 1 - AHB to APB2 Bridge clock enable"]
-            #[inline]
-            pub fn ahb2apb2_cken(&mut self) -> _AHB2APB2_CKENW {
-                _AHB2APB2_CKENW { w: self }
-            }
-            #[doc = "Bit 2 - Cortex M4 ETM clock enable"]
-            #[inline]
-            pub fn cm4dbg_cken(&mut self) -> _CM4DBG_CKENW {
-                _CM4DBG_CKENW { w: self }
-            }
-            #[doc = "Bit 3 - Spare clock enable"]
-            #[inline]
-            pub fn spare_cken(&mut self) -> _SPARE_CKENW {
-                _SPARE_CKENW { w: self }
-            }
-            #[doc = "Bit 4 - SRQAM controller clock enable"]
-            #[inline]
-            pub fn sram_cken(&mut self) -> _SRAM_CKENW {
-                _SRAM_CKENW { w: self }
-            }
-            #[doc = "Bit 5 - Flash Interface clock enable"]
-            #[inline]
-            pub fn flitf_cken(&mut self) -> _FLITF_CKENW {
-                _FLITF_CKENW { w: self }
-            }
-            #[doc = "Bit 6 - RCC clock enable"]
-            #[inline]
-            pub fn rcc_cken(&mut self) -> _RCC_CKENW {
-                _RCC_CKENW { w: self }
-            }
-            #[doc = "Bit 7 - EVTCL_CKEN"]
-            #[inline]
-            pub fn evtcl_cken(&mut self) -> _EVTCL_CKENW {
-                _EVTCL_CKENW { w: self }
-            }
-        }
-    }
-    #[doc = "Dedicated Clocks Configuration Register"]
-    pub struct DCKCFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Dedicated Clocks Configuration Register"]
-    pub mod dckcfgr2 {
-        #[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::DCKCFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct CKSDIOSELR {
-            bits: bool,
-        }
-        impl CKSDIOSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CK48MSELR {
-            bits: bool,
-        }
-        impl CK48MSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2CFMP1SELR {
-            bits: bool,
-        }
-        impl I2CFMP1SELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKSDIOSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKSDIOSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CK48MSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CK48MSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2CFMP1SELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2CFMP1SELW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 28 - SDIO clock selection."]
-            #[inline]
-            pub fn cksdiosel(&self) -> CKSDIOSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKSDIOSELR { bits }
-            }
-            #[doc = "Bit 27 - SDIO/USBFS clock selection."]
-            #[inline]
-            pub fn ck48msel(&self) -> CK48MSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CK48MSELR { bits }
-            }
-            #[doc = "Bit 22 - I2CFMP1 kernel clock source selection"]
-            #[inline]
-            pub fn i2cfmp1sel(&self) -> I2CFMP1SELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2CFMP1SELR { bits }
-            }
-        }
-        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 28 - SDIO clock selection."]
-            #[inline]
-            pub fn cksdiosel(&mut self) -> _CKSDIOSELW {
-                _CKSDIOSELW { w: self }
-            }
-            #[doc = "Bit 27 - SDIO/USBFS clock selection."]
-            #[inline]
-            pub fn ck48msel(&mut self) -> _CK48MSELW {
-                _CK48MSELW { w: self }
-            }
-            #[doc = "Bit 22 - I2CFMP1 kernel clock source selection"]
-            #[inline]
-            pub fn i2cfmp1sel(&mut self) -> _I2CFMP1SELW {
-                _I2CFMP1SELW { w: self }
-            }
-        }
-    }
-}
-#[doc = "Real-time clock"]
-pub struct RTC {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for RTC {}
-impl RTC {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const rtc::RegisterBlock {
-        0x4000_2800 as *const _
-    }
-}
-impl Deref for RTC {
-    type Target = rtc::RegisterBlock;
-    fn deref(&self) -> &rtc::RegisterBlock {
-        unsafe { &*RTC::ptr() }
-    }
-}
-#[doc = "Real-time clock"]
-pub mod rtc {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - time register"]
-        pub tr: TR,
-        #[doc = "0x04 - date register"]
-        pub dr: DR,
-        #[doc = "0x08 - control register"]
-        pub cr: CR,
-        #[doc = "0x0c - initialization and status register"]
-        pub isr: ISR,
-        #[doc = "0x10 - prescaler register"]
-        pub prer: PRER,
-        #[doc = "0x14 - wakeup timer register"]
-        pub wutr: WUTR,
-        #[doc = "0x18 - calibration register"]
-        pub calibr: CALIBR,
-        #[doc = "0x1c - alarm A register"]
-        pub alrmar: ALRMAR,
-        #[doc = "0x20 - alarm B register"]
-        pub alrmbr: ALRMBR,
-        #[doc = "0x24 - write protection register"]
-        pub wpr: WPR,
-        #[doc = "0x28 - sub second register"]
-        pub ssr: SSR,
-        #[doc = "0x2c - shift control register"]
-        pub shiftr: SHIFTR,
-        #[doc = "0x30 - time stamp time register"]
-        pub tstr: TSTR,
-        #[doc = "0x34 - time stamp date register"]
-        pub tsdr: TSDR,
-        #[doc = "0x38 - timestamp sub second register"]
-        pub tsssr: TSSSR,
-        #[doc = "0x3c - calibration register"]
-        pub calr: CALR,
-        #[doc = "0x40 - tamper and alternate function configuration register"]
-        pub tafcr: TAFCR,
-        #[doc = "0x44 - alarm A sub second register"]
-        pub alrmassr: ALRMASSR,
-        #[doc = "0x48 - alarm B sub second register"]
-        pub alrmbssr: ALRMBSSR,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x50 - backup register"]
-        pub bkp0r: BKP0R,
-        #[doc = "0x54 - backup register"]
-        pub bkp1r: BKP1R,
-        #[doc = "0x58 - backup register"]
-        pub bkp2r: BKP2R,
-        #[doc = "0x5c - backup register"]
-        pub bkp3r: BKP3R,
-        #[doc = "0x60 - backup register"]
-        pub bkp4r: BKP4R,
-        #[doc = "0x64 - backup register"]
-        pub bkp5r: BKP5R,
-        #[doc = "0x68 - backup register"]
-        pub bkp6r: BKP6R,
-        #[doc = "0x6c - backup register"]
-        pub bkp7r: BKP7R,
-        #[doc = "0x70 - backup register"]
-        pub bkp8r: BKP8R,
-        #[doc = "0x74 - backup register"]
-        pub bkp9r: BKP9R,
-        #[doc = "0x78 - backup register"]
-        pub bkp10r: BKP10R,
-        #[doc = "0x7c - backup register"]
-        pub bkp11r: BKP11R,
-        #[doc = "0x80 - backup register"]
-        pub bkp12r: BKP12R,
-        #[doc = "0x84 - backup register"]
-        pub bkp13r: BKP13R,
-        #[doc = "0x88 - backup register"]
-        pub bkp14r: BKP14R,
-        #[doc = "0x8c - backup register"]
-        pub bkp15r: BKP15R,
-        #[doc = "0x90 - backup register"]
-        pub bkp16r: BKP16R,
-        #[doc = "0x94 - backup register"]
-        pub bkp17r: BKP17R,
-        #[doc = "0x98 - backup register"]
-        pub bkp18r: BKP18R,
-        #[doc = "0x9c - backup register"]
-        pub bkp19r: BKP19R,
-    }
-    #[doc = "time register"]
-    pub struct TR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "time register"]
-    pub mod tr {
-        #[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::TR {
-            #[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 = r" Value of the field"]
-        pub struct PMR {
-            bits: bool,
-        }
-        impl PMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTR {
-            bits: u8,
-        }
-        impl HTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct HUR {
-            bits: u8,
-        }
-        impl HUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MNTR {
-            bits: u8,
-        }
-        impl MNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MNUR {
-            bits: u8,
-        }
-        impl MNUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STR {
-            bits: u8,
-        }
-        impl STR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SUR {
-            bits: u8,
-        }
-        impl SUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MNUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MNUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _STW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 = "Bit 22 - AM/PM notation"]
-            #[inline]
-            pub fn pm(&self) -> PMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PMR { bits }
-            }
-            #[doc = "Bits 20:21 - Hour tens in BCD format"]
-            #[inline]
-            pub fn ht(&self) -> HTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HTR { bits }
-            }
-            #[doc = "Bits 16:19 - Hour units in BCD format"]
-            #[inline]
-            pub fn hu(&self) -> HUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HUR { bits }
-            }
-            #[doc = "Bits 12:14 - Minute tens in BCD format"]
-            #[inline]
-            pub fn mnt(&self) -> MNTR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MNTR { bits }
-            }
-            #[doc = "Bits 8:11 - Minute units in BCD format"]
-            #[inline]
-            pub fn mnu(&self) -> MNUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MNUR { bits }
-            }
-            #[doc = "Bits 4:6 - Second tens in BCD format"]
-            #[inline]
-            pub fn st(&self) -> STR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                STR { bits }
-            }
-            #[doc = "Bits 0:3 - Second units in BCD format"]
-            #[inline]
-            pub fn su(&self) -> SUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SUR { bits }
-            }
-        }
-        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 22 - AM/PM notation"]
-            #[inline]
-            pub fn pm(&mut self) -> _PMW {
-                _PMW { w: self }
-            }
-            #[doc = "Bits 20:21 - Hour tens in BCD format"]
-            #[inline]
-            pub fn ht(&mut self) -> _HTW {
-                _HTW { w: self }
-            }
-            #[doc = "Bits 16:19 - Hour units in BCD format"]
-            #[inline]
-            pub fn hu(&mut self) -> _HUW {
-                _HUW { w: self }
-            }
-            #[doc = "Bits 12:14 - Minute tens in BCD format"]
-            #[inline]
-            pub fn mnt(&mut self) -> _MNTW {
-                _MNTW { w: self }
-            }
-            #[doc = "Bits 8:11 - Minute units in BCD format"]
-            #[inline]
-            pub fn mnu(&mut self) -> _MNUW {
-                _MNUW { w: self }
-            }
-            #[doc = "Bits 4:6 - Second tens in BCD format"]
-            #[inline]
-            pub fn st(&mut self) -> _STW {
-                _STW { w: self }
-            }
-            #[doc = "Bits 0:3 - Second units in BCD format"]
-            #[inline]
-            pub fn su(&mut self) -> _SUW {
-                _SUW { w: self }
-            }
-        }
-    }
-    #[doc = "date register"]
-    pub struct DR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "date register"]
-    pub mod dr {
-        #[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::DR {
-            #[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 = r" Value of the field"]
-        pub struct YTR {
-            bits: u8,
-        }
-        impl YTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct YUR {
-            bits: u8,
-        }
-        impl YUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct WDUR {
-            bits: u8,
-        }
-        impl WDUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MTR {
-            bits: bool,
-        }
-        impl MTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUR {
-            bits: u8,
-        }
-        impl MUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTR {
-            bits: u8,
-        }
-        impl DTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DUR {
-            bits: u8,
-        }
-        impl DUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _YTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _YTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _YUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _YUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 20:23 - Year tens in BCD format"]
-            #[inline]
-            pub fn yt(&self) -> YTR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                YTR { bits }
-            }
-            #[doc = "Bits 16:19 - Year units in BCD format"]
-            #[inline]
-            pub fn yu(&self) -> YUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                YUR { bits }
-            }
-            #[doc = "Bits 13:15 - Week day units"]
-            #[inline]
-            pub fn wdu(&self) -> WDUR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                WDUR { bits }
-            }
-            #[doc = "Bit 12 - Month tens in BCD format"]
-            #[inline]
-            pub fn mt(&self) -> MTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MTR { bits }
-            }
-            #[doc = "Bits 8:11 - Month units in BCD format"]
-            #[inline]
-            pub fn mu(&self) -> MUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MUR { bits }
-            }
-            #[doc = "Bits 4:5 - Date tens in BCD format"]
-            #[inline]
-            pub fn dt(&self) -> DTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTR { bits }
-            }
-            #[doc = "Bits 0:3 - Date units in BCD format"]
-            #[inline]
-            pub fn du(&self) -> DUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DUR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x2101 }
-            }
-            #[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 20:23 - Year tens in BCD format"]
-            #[inline]
-            pub fn yt(&mut self) -> _YTW {
-                _YTW { w: self }
-            }
-            #[doc = "Bits 16:19 - Year units in BCD format"]
-            #[inline]
-            pub fn yu(&mut self) -> _YUW {
-                _YUW { w: self }
-            }
-            #[doc = "Bits 13:15 - Week day units"]
-            #[inline]
-            pub fn wdu(&mut self) -> _WDUW {
-                _WDUW { w: self }
-            }
-            #[doc = "Bit 12 - Month tens in BCD format"]
-            #[inline]
-            pub fn mt(&mut self) -> _MTW {
-                _MTW { w: self }
-            }
-            #[doc = "Bits 8:11 - Month units in BCD format"]
-            #[inline]
-            pub fn mu(&mut self) -> _MUW {
-                _MUW { w: self }
-            }
-            #[doc = "Bits 4:5 - Date tens in BCD format"]
-            #[inline]
-            pub fn dt(&mut self) -> _DTW {
-                _DTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Date units in BCD format"]
-            #[inline]
-            pub fn du(&mut self) -> _DUW {
-                _DUW { w: self }
-            }
-        }
-    }
-    #[doc = "control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct COER {
-            bits: bool,
-        }
-        impl COER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OSELR {
-            bits: u8,
-        }
-        impl OSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct POLR {
-            bits: bool,
-        }
-        impl POLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct COSELR {
-            bits: bool,
-        }
-        impl COSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BKPR {
-            bits: bool,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SUB1HR {
-            bits: bool,
-        }
-        impl SUB1HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADD1HR {
-            bits: bool,
-        }
-        impl ADD1HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSIER {
-            bits: bool,
-        }
-        impl TSIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WUTIER {
-            bits: bool,
-        }
-        impl WUTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALRBIER {
-            bits: bool,
-        }
-        impl ALRBIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALRAIER {
-            bits: bool,
-        }
-        impl ALRAIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSER {
-            bits: bool,
-        }
-        impl TSER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WUTER {
-            bits: bool,
-        }
-        impl WUTER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALRBER {
-            bits: bool,
-        }
-        impl ALRBER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALRAER {
-            bits: bool,
-        }
-        impl ALRAER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DCER {
-            bits: bool,
-        }
-        impl DCER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FMTR {
-            bits: bool,
-        }
-        impl FMTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BYPSHADR {
-            bits: bool,
-        }
-        impl BYPSHADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REFCKONR {
-            bits: bool,
-        }
-        impl REFCKONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSEDGER {
-            bits: bool,
-        }
-        impl TSEDGER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WCKSELR {
-            bits: u8,
-        }
-        impl WCKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _COEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _POLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _POLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _COSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SUB1HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SUB1HW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADD1HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADD1HW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WUTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WUTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALRBIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALRBIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALRAIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALRAIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WUTEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WUTEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALRBEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALRBEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALRAEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALRAEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DCEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FMTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FMTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BYPSHADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BYPSHADW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _REFCKONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _REFCKONW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSEDGEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSEDGEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WCKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WCKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 = "Bit 23 - Calibration output enable"]
-            #[inline]
-            pub fn coe(&self) -> COER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                COER { bits }
-            }
-            #[doc = "Bits 21:22 - Output selection"]
-            #[inline]
-            pub fn osel(&self) -> OSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSELR { bits }
-            }
-            #[doc = "Bit 20 - Output polarity"]
-            #[inline]
-            pub fn pol(&self) -> POLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                POLR { bits }
-            }
-            #[doc = "Bit 19 - Calibration Output selection"]
-            #[inline]
-            pub fn cosel(&self) -> COSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                COSELR { bits }
-            }
-            #[doc = "Bit 18 - Backup"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BKPR { bits }
-            }
-            #[doc = "Bit 17 - Subtract 1 hour (winter time change)"]
-            #[inline]
-            pub fn sub1h(&self) -> SUB1HR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SUB1HR { bits }
-            }
-            #[doc = "Bit 16 - Add 1 hour (summer time change)"]
-            #[inline]
-            pub fn add1h(&self) -> ADD1HR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADD1HR { bits }
-            }
-            #[doc = "Bit 15 - Time-stamp interrupt enable"]
-            #[inline]
-            pub fn tsie(&self) -> TSIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TSIER { bits }
-            }
-            #[doc = "Bit 14 - Wakeup timer interrupt enable"]
-            #[inline]
-            pub fn wutie(&self) -> WUTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WUTIER { bits }
-            }
-            #[doc = "Bit 13 - Alarm B interrupt enable"]
-            #[inline]
-            pub fn alrbie(&self) -> ALRBIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALRBIER { bits }
-            }
-            #[doc = "Bit 12 - Alarm A interrupt enable"]
-            #[inline]
-            pub fn alraie(&self) -> ALRAIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALRAIER { bits }
-            }
-            #[doc = "Bit 11 - Time stamp enable"]
-            #[inline]
-            pub fn tse(&self) -> TSER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TSER { bits }
-            }
-            #[doc = "Bit 10 - Wakeup timer enable"]
-            #[inline]
-            pub fn wute(&self) -> WUTER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WUTER { bits }
-            }
-            #[doc = "Bit 9 - Alarm B enable"]
-            #[inline]
-            pub fn alrbe(&self) -> ALRBER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALRBER { bits }
-            }
-            #[doc = "Bit 8 - Alarm A enable"]
-            #[inline]
-            pub fn alrae(&self) -> ALRAER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALRAER { bits }
-            }
-            #[doc = "Bit 7 - Coarse digital calibration enable"]
-            #[inline]
-            pub fn dce(&self) -> DCER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCER { bits }
-            }
-            #[doc = "Bit 6 - Hour format"]
-            #[inline]
-            pub fn fmt(&self) -> FMTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FMTR { bits }
-            }
-            #[doc = "Bit 5 - Bypass the shadow registers"]
-            #[inline]
-            pub fn bypshad(&self) -> BYPSHADR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BYPSHADR { bits }
-            }
-            #[doc = "Bit 4 - Reference clock detection enable (50 or 60 Hz)"]
-            #[inline]
-            pub fn refckon(&self) -> REFCKONR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REFCKONR { bits }
-            }
-            #[doc = "Bit 3 - Time-stamp event active edge"]
-            #[inline]
-            pub fn tsedge(&self) -> TSEDGER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TSEDGER { bits }
-            }
-            #[doc = "Bits 0:2 - Wakeup clock selection"]
-            #[inline]
-            pub fn wcksel(&self) -> WCKSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                WCKSELR { bits }
-            }
-        }
-        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 23 - Calibration output enable"]
-            #[inline]
-            pub fn coe(&mut self) -> _COEW {
-                _COEW { w: self }
-            }
-            #[doc = "Bits 21:22 - Output selection"]
-            #[inline]
-            pub fn osel(&mut self) -> _OSELW {
-                _OSELW { w: self }
-            }
-            #[doc = "Bit 20 - Output polarity"]
-            #[inline]
-            pub fn pol(&mut self) -> _POLW {
-                _POLW { w: self }
-            }
-            #[doc = "Bit 19 - Calibration Output selection"]
-            #[inline]
-            pub fn cosel(&mut self) -> _COSELW {
-                _COSELW { w: self }
-            }
-            #[doc = "Bit 18 - Backup"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-            #[doc = "Bit 17 - Subtract 1 hour (winter time change)"]
-            #[inline]
-            pub fn sub1h(&mut self) -> _SUB1HW {
-                _SUB1HW { w: self }
-            }
-            #[doc = "Bit 16 - Add 1 hour (summer time change)"]
-            #[inline]
-            pub fn add1h(&mut self) -> _ADD1HW {
-                _ADD1HW { w: self }
-            }
-            #[doc = "Bit 15 - Time-stamp interrupt enable"]
-            #[inline]
-            pub fn tsie(&mut self) -> _TSIEW {
-                _TSIEW { w: self }
-            }
-            #[doc = "Bit 14 - Wakeup timer interrupt enable"]
-            #[inline]
-            pub fn wutie(&mut self) -> _WUTIEW {
-                _WUTIEW { w: self }
-            }
-            #[doc = "Bit 13 - Alarm B interrupt enable"]
-            #[inline]
-            pub fn alrbie(&mut self) -> _ALRBIEW {
-                _ALRBIEW { w: self }
-            }
-            #[doc = "Bit 12 - Alarm A interrupt enable"]
-            #[inline]
-            pub fn alraie(&mut self) -> _ALRAIEW {
-                _ALRAIEW { w: self }
-            }
-            #[doc = "Bit 11 - Time stamp enable"]
-            #[inline]
-            pub fn tse(&mut self) -> _TSEW {
-                _TSEW { w: self }
-            }
-            #[doc = "Bit 10 - Wakeup timer enable"]
-            #[inline]
-            pub fn wute(&mut self) -> _WUTEW {
-                _WUTEW { w: self }
-            }
-            #[doc = "Bit 9 - Alarm B enable"]
-            #[inline]
-            pub fn alrbe(&mut self) -> _ALRBEW {
-                _ALRBEW { w: self }
-            }
-            #[doc = "Bit 8 - Alarm A enable"]
-            #[inline]
-            pub fn alrae(&mut self) -> _ALRAEW {
-                _ALRAEW { w: self }
-            }
-            #[doc = "Bit 7 - Coarse digital calibration enable"]
-            #[inline]
-            pub fn dce(&mut self) -> _DCEW {
-                _DCEW { w: self }
-            }
-            #[doc = "Bit 6 - Hour format"]
-            #[inline]
-            pub fn fmt(&mut self) -> _FMTW {
-                _FMTW { w: self }
-            }
-            #[doc = "Bit 5 - Bypass the shadow registers"]
-            #[inline]
-            pub fn bypshad(&mut self) -> _BYPSHADW {
-                _BYPSHADW { w: self }
-            }
-            #[doc = "Bit 4 - Reference clock detection enable (50 or 60 Hz)"]
-            #[inline]
-            pub fn refckon(&mut self) -> _REFCKONW {
-                _REFCKONW { w: self }
-            }
-            #[doc = "Bit 3 - Time-stamp event active edge"]
-            #[inline]
-            pub fn tsedge(&mut self) -> _TSEDGEW {
-                _TSEDGEW { w: self }
-            }
-            #[doc = "Bits 0:2 - Wakeup clock selection"]
-            #[inline]
-            pub fn wcksel(&mut self) -> _WCKSELW {
-                _WCKSELW { w: self }
-            }
-        }
-    }
-    #[doc = "initialization and status register"]
-    pub struct ISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "initialization and status register"]
-    pub mod isr {
-        #[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::ISR {
-            #[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 = r" Value of the field"]
-        pub struct ALRAWFR {
-            bits: bool,
-        }
-        impl ALRAWFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALRBWFR {
-            bits: bool,
-        }
-        impl ALRBWFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WUTWFR {
-            bits: bool,
-        }
-        impl WUTWFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SHPFR {
-            bits: bool,
-        }
-        impl SHPFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INITSR {
-            bits: bool,
-        }
-        impl INITSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSFR {
-            bits: bool,
-        }
-        impl RSFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INITFR {
-            bits: bool,
-        }
-        impl INITFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INITR {
-            bits: bool,
-        }
-        impl INITR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALRAFR {
-            bits: bool,
-        }
-        impl ALRAFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALRBFR {
-            bits: bool,
-        }
-        impl ALRBFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WUTFR {
-            bits: bool,
-        }
-        impl WUTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSFR {
-            bits: bool,
-        }
-        impl TSFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSOVFR {
-            bits: bool,
-        }
-        impl TSOVFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMP1FR {
-            bits: bool,
-        }
-        impl TAMP1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMP2FR {
-            bits: bool,
-        }
-        impl TAMP2FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RECALPFR {
-            bits: bool,
-        }
-        impl RECALPFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SHPFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SHPFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _INITW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INITW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALRAFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALRAFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALRBFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALRBFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WUTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WUTFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSOVFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSOVFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMP1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMP1FW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMP2FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMP2FW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Alarm A write flag"]
-            #[inline]
-            pub fn alrawf(&self) -> ALRAWFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALRAWFR { bits }
-            }
-            #[doc = "Bit 1 - Alarm B write flag"]
-            #[inline]
-            pub fn alrbwf(&self) -> ALRBWFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALRBWFR { bits }
-            }
-            #[doc = "Bit 2 - Wakeup timer write flag"]
-            #[inline]
-            pub fn wutwf(&self) -> WUTWFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WUTWFR { bits }
-            }
-            #[doc = "Bit 3 - Shift operation pending"]
-            #[inline]
-            pub fn shpf(&self) -> SHPFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SHPFR { bits }
-            }
-            #[doc = "Bit 4 - Initialization status flag"]
-            #[inline]
-            pub fn inits(&self) -> INITSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INITSR { bits }
-            }
-            #[doc = "Bit 5 - Registers synchronization flag"]
-            #[inline]
-            pub fn rsf(&self) -> RSFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSFR { bits }
-            }
-            #[doc = "Bit 6 - Initialization flag"]
-            #[inline]
-            pub fn initf(&self) -> INITFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INITFR { bits }
-            }
-            #[doc = "Bit 7 - Initialization mode"]
-            #[inline]
-            pub fn init(&self) -> INITR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INITR { bits }
-            }
-            #[doc = "Bit 8 - Alarm A flag"]
-            #[inline]
-            pub fn alraf(&self) -> ALRAFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALRAFR { bits }
-            }
-            #[doc = "Bit 9 - Alarm B flag"]
-            #[inline]
-            pub fn alrbf(&self) -> ALRBFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALRBFR { bits }
-            }
-            #[doc = "Bit 10 - Wakeup timer flag"]
-            #[inline]
-            pub fn wutf(&self) -> WUTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WUTFR { bits }
-            }
-            #[doc = "Bit 11 - Time-stamp flag"]
-            #[inline]
-            pub fn tsf(&self) -> TSFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TSFR { bits }
-            }
-            #[doc = "Bit 12 - Time-stamp overflow flag"]
-            #[inline]
-            pub fn tsovf(&self) -> TSOVFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TSOVFR { bits }
-            }
-            #[doc = "Bit 13 - Tamper detection flag"]
-            #[inline]
-            pub fn tamp1f(&self) -> TAMP1FR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMP1FR { bits }
-            }
-            #[doc = "Bit 14 - TAMPER2 detection flag"]
-            #[inline]
-            pub fn tamp2f(&self) -> TAMP2FR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMP2FR { bits }
-            }
-            #[doc = "Bit 16 - Recalibration pending Flag"]
-            #[inline]
-            pub fn recalpf(&self) -> RECALPFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RECALPFR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x07 }
-            }
-            #[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 3 - Shift operation pending"]
-            #[inline]
-            pub fn shpf(&mut self) -> _SHPFW {
-                _SHPFW { w: self }
-            }
-            #[doc = "Bit 5 - Registers synchronization flag"]
-            #[inline]
-            pub fn rsf(&mut self) -> _RSFW {
-                _RSFW { w: self }
-            }
-            #[doc = "Bit 7 - Initialization mode"]
-            #[inline]
-            pub fn init(&mut self) -> _INITW {
-                _INITW { w: self }
-            }
-            #[doc = "Bit 8 - Alarm A flag"]
-            #[inline]
-            pub fn alraf(&mut self) -> _ALRAFW {
-                _ALRAFW { w: self }
-            }
-            #[doc = "Bit 9 - Alarm B flag"]
-            #[inline]
-            pub fn alrbf(&mut self) -> _ALRBFW {
-                _ALRBFW { w: self }
-            }
-            #[doc = "Bit 10 - Wakeup timer flag"]
-            #[inline]
-            pub fn wutf(&mut self) -> _WUTFW {
-                _WUTFW { w: self }
-            }
-            #[doc = "Bit 11 - Time-stamp flag"]
-            #[inline]
-            pub fn tsf(&mut self) -> _TSFW {
-                _TSFW { w: self }
-            }
-            #[doc = "Bit 12 - Time-stamp overflow flag"]
-            #[inline]
-            pub fn tsovf(&mut self) -> _TSOVFW {
-                _TSOVFW { w: self }
-            }
-            #[doc = "Bit 13 - Tamper detection flag"]
-            #[inline]
-            pub fn tamp1f(&mut self) -> _TAMP1FW {
-                _TAMP1FW { w: self }
-            }
-            #[doc = "Bit 14 - TAMPER2 detection flag"]
-            #[inline]
-            pub fn tamp2f(&mut self) -> _TAMP2FW {
-                _TAMP2FW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler register"]
-    pub struct PRER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler register"]
-    pub mod prer {
-        #[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::PRER {
-            #[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 = r" Value of the field"]
-        pub struct PREDIV_AR {
-            bits: u8,
-        }
-        impl PREDIV_AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PREDIV_SR {
-            bits: u16,
-        }
-        impl PREDIV_SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PREDIV_AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PREDIV_AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PREDIV_SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PREDIV_SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x7fff;
-                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 16:22 - Asynchronous prescaler factor"]
-            #[inline]
-            pub fn prediv_a(&self) -> PREDIV_AR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PREDIV_AR { bits }
-            }
-            #[doc = "Bits 0:14 - Synchronous prescaler factor"]
-            #[inline]
-            pub fn prediv_s(&self) -> PREDIV_SR {
-                let bits = {
-                    const MASK: u16 = 0x7fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PREDIV_SR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x007f_00ff }
-            }
-            #[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 16:22 - Asynchronous prescaler factor"]
-            #[inline]
-            pub fn prediv_a(&mut self) -> _PREDIV_AW {
-                _PREDIV_AW { w: self }
-            }
-            #[doc = "Bits 0:14 - Synchronous prescaler factor"]
-            #[inline]
-            pub fn prediv_s(&mut self) -> _PREDIV_SW {
-                _PREDIV_SW { w: self }
-            }
-        }
-    }
-    #[doc = "wakeup timer register"]
-    pub struct WUTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "wakeup timer register"]
-    pub mod wutr {
-        #[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::WUTR {
-            #[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 = r" Value of the field"]
-        pub struct WUTR {
-            bits: u16,
-        }
-        impl WUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WUTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WUTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Wakeup auto-reload value bits"]
-            #[inline]
-            pub fn wut(&self) -> WUTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WUTR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xffff }
-            }
-            #[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 0:15 - Wakeup auto-reload value bits"]
-            #[inline]
-            pub fn wut(&mut self) -> _WUTW {
-                _WUTW { w: self }
-            }
-        }
-    }
-    #[doc = "calibration register"]
-    pub struct CALIBR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "calibration register"]
-    pub mod calibr {
-        #[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::CALIBR {
-            #[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 = r" Value of the field"]
-        pub struct DCSR {
-            bits: bool,
-        }
-        impl DCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DCR {
-            bits: u8,
-        }
-        impl DCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 = "Bit 7 - Digital calibration sign"]
-            #[inline]
-            pub fn dcs(&self) -> DCSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCSR { bits }
-            }
-            #[doc = "Bits 0:4 - Digital calibration"]
-            #[inline]
-            pub fn dc(&self) -> DCR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DCR { bits }
-            }
-        }
-        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 7 - Digital calibration sign"]
-            #[inline]
-            pub fn dcs(&mut self) -> _DCSW {
-                _DCSW { w: self }
-            }
-            #[doc = "Bits 0:4 - Digital calibration"]
-            #[inline]
-            pub fn dc(&mut self) -> _DCW {
-                _DCW { w: self }
-            }
-        }
-    }
-    #[doc = "alarm A register"]
-    pub struct ALRMAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "alarm A register"]
-    pub mod alrmar {
-        #[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::ALRMAR {
-            #[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 = r" Value of the field"]
-        pub struct MSK4R {
-            bits: bool,
-        }
-        impl MSK4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WDSELR {
-            bits: bool,
-        }
-        impl WDSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTR {
-            bits: u8,
-        }
-        impl DTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DUR {
-            bits: u8,
-        }
-        impl DUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSK3R {
-            bits: bool,
-        }
-        impl MSK3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PMR {
-            bits: bool,
-        }
-        impl PMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTR {
-            bits: u8,
-        }
-        impl HTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct HUR {
-            bits: u8,
-        }
-        impl HUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSK2R {
-            bits: bool,
-        }
-        impl MSK2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MNTR {
-            bits: u8,
-        }
-        impl MNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MNUR {
-            bits: u8,
-        }
-        impl MNUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSK1R {
-            bits: bool,
-        }
-        impl MSK1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STR {
-            bits: u8,
-        }
-        impl STR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SUR {
-            bits: u8,
-        }
-        impl SUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSK4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSK4W<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSK3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSK3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSK2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSK2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MNUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MNUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSK1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSK1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 = "Bit 31 - Alarm A date mask"]
-            #[inline]
-            pub fn msk4(&self) -> MSK4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSK4R { bits }
-            }
-            #[doc = "Bit 30 - Week day selection"]
-            #[inline]
-            pub fn wdsel(&self) -> WDSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WDSELR { bits }
-            }
-            #[doc = "Bits 28:29 - Date tens in BCD format"]
-            #[inline]
-            pub fn dt(&self) -> DTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTR { bits }
-            }
-            #[doc = "Bits 24:27 - Date units or day in BCD format"]
-            #[inline]
-            pub fn du(&self) -> DUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DUR { bits }
-            }
-            #[doc = "Bit 23 - Alarm A hours mask"]
-            #[inline]
-            pub fn msk3(&self) -> MSK3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSK3R { bits }
-            }
-            #[doc = "Bit 22 - AM/PM notation"]
-            #[inline]
-            pub fn pm(&self) -> PMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PMR { bits }
-            }
-            #[doc = "Bits 20:21 - Hour tens in BCD format"]
-            #[inline]
-            pub fn ht(&self) -> HTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HTR { bits }
-            }
-            #[doc = "Bits 16:19 - Hour units in BCD format"]
-            #[inline]
-            pub fn hu(&self) -> HUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HUR { bits }
-            }
-            #[doc = "Bit 15 - Alarm A minutes mask"]
-            #[inline]
-            pub fn msk2(&self) -> MSK2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSK2R { bits }
-            }
-            #[doc = "Bits 12:14 - Minute tens in BCD format"]
-            #[inline]
-            pub fn mnt(&self) -> MNTR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MNTR { bits }
-            }
-            #[doc = "Bits 8:11 - Minute units in BCD format"]
-            #[inline]
-            pub fn mnu(&self) -> MNUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MNUR { bits }
-            }
-            #[doc = "Bit 7 - Alarm A seconds mask"]
-            #[inline]
-            pub fn msk1(&self) -> MSK1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSK1R { bits }
-            }
-            #[doc = "Bits 4:6 - Second tens in BCD format"]
-            #[inline]
-            pub fn st(&self) -> STR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                STR { bits }
-            }
-            #[doc = "Bits 0:3 - Second units in BCD format"]
-            #[inline]
-            pub fn su(&self) -> SUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SUR { bits }
-            }
-        }
-        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 31 - Alarm A date mask"]
-            #[inline]
-            pub fn msk4(&mut self) -> _MSK4W {
-                _MSK4W { w: self }
-            }
-            #[doc = "Bit 30 - Week day selection"]
-            #[inline]
-            pub fn wdsel(&mut self) -> _WDSELW {
-                _WDSELW { w: self }
-            }
-            #[doc = "Bits 28:29 - Date tens in BCD format"]
-            #[inline]
-            pub fn dt(&mut self) -> _DTW {
-                _DTW { w: self }
-            }
-            #[doc = "Bits 24:27 - Date units or day in BCD format"]
-            #[inline]
-            pub fn du(&mut self) -> _DUW {
-                _DUW { w: self }
-            }
-            #[doc = "Bit 23 - Alarm A hours mask"]
-            #[inline]
-            pub fn msk3(&mut self) -> _MSK3W {
-                _MSK3W { w: self }
-            }
-            #[doc = "Bit 22 - AM/PM notation"]
-            #[inline]
-            pub fn pm(&mut self) -> _PMW {
-                _PMW { w: self }
-            }
-            #[doc = "Bits 20:21 - Hour tens in BCD format"]
-            #[inline]
-            pub fn ht(&mut self) -> _HTW {
-                _HTW { w: self }
-            }
-            #[doc = "Bits 16:19 - Hour units in BCD format"]
-            #[inline]
-            pub fn hu(&mut self) -> _HUW {
-                _HUW { w: self }
-            }
-            #[doc = "Bit 15 - Alarm A minutes mask"]
-            #[inline]
-            pub fn msk2(&mut self) -> _MSK2W {
-                _MSK2W { w: self }
-            }
-            #[doc = "Bits 12:14 - Minute tens in BCD format"]
-            #[inline]
-            pub fn mnt(&mut self) -> _MNTW {
-                _MNTW { w: self }
-            }
-            #[doc = "Bits 8:11 - Minute units in BCD format"]
-            #[inline]
-            pub fn mnu(&mut self) -> _MNUW {
-                _MNUW { w: self }
-            }
-            #[doc = "Bit 7 - Alarm A seconds mask"]
-            #[inline]
-            pub fn msk1(&mut self) -> _MSK1W {
-                _MSK1W { w: self }
-            }
-            #[doc = "Bits 4:6 - Second tens in BCD format"]
-            #[inline]
-            pub fn st(&mut self) -> _STW {
-                _STW { w: self }
-            }
-            #[doc = "Bits 0:3 - Second units in BCD format"]
-            #[inline]
-            pub fn su(&mut self) -> _SUW {
-                _SUW { w: self }
-            }
-        }
-    }
-    #[doc = "alarm B register"]
-    pub struct ALRMBR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "alarm B register"]
-    pub mod alrmbr {
-        #[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::ALRMBR {
-            #[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 = r" Value of the field"]
-        pub struct MSK4R {
-            bits: bool,
-        }
-        impl MSK4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WDSELR {
-            bits: bool,
-        }
-        impl WDSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTR {
-            bits: u8,
-        }
-        impl DTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DUR {
-            bits: u8,
-        }
-        impl DUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSK3R {
-            bits: bool,
-        }
-        impl MSK3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PMR {
-            bits: bool,
-        }
-        impl PMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTR {
-            bits: u8,
-        }
-        impl HTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct HUR {
-            bits: u8,
-        }
-        impl HUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSK2R {
-            bits: bool,
-        }
-        impl MSK2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MNTR {
-            bits: u8,
-        }
-        impl MNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MNUR {
-            bits: u8,
-        }
-        impl MNUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSK1R {
-            bits: bool,
-        }
-        impl MSK1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STR {
-            bits: u8,
-        }
-        impl STR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SUR {
-            bits: u8,
-        }
-        impl SUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSK4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSK4W<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSK3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSK3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSK2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSK2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MNUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MNUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSK1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSK1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SUW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 = "Bit 31 - Alarm B date mask"]
-            #[inline]
-            pub fn msk4(&self) -> MSK4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSK4R { bits }
-            }
-            #[doc = "Bit 30 - Week day selection"]
-            #[inline]
-            pub fn wdsel(&self) -> WDSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WDSELR { bits }
-            }
-            #[doc = "Bits 28:29 - Date tens in BCD format"]
-            #[inline]
-            pub fn dt(&self) -> DTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTR { bits }
-            }
-            #[doc = "Bits 24:27 - Date units or day in BCD format"]
-            #[inline]
-            pub fn du(&self) -> DUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DUR { bits }
-            }
-            #[doc = "Bit 23 - Alarm B hours mask"]
-            #[inline]
-            pub fn msk3(&self) -> MSK3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSK3R { bits }
-            }
-            #[doc = "Bit 22 - AM/PM notation"]
-            #[inline]
-            pub fn pm(&self) -> PMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PMR { bits }
-            }
-            #[doc = "Bits 20:21 - Hour tens in BCD format"]
-            #[inline]
-            pub fn ht(&self) -> HTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HTR { bits }
-            }
-            #[doc = "Bits 16:19 - Hour units in BCD format"]
-            #[inline]
-            pub fn hu(&self) -> HUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HUR { bits }
-            }
-            #[doc = "Bit 15 - Alarm B minutes mask"]
-            #[inline]
-            pub fn msk2(&self) -> MSK2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSK2R { bits }
-            }
-            #[doc = "Bits 12:14 - Minute tens in BCD format"]
-            #[inline]
-            pub fn mnt(&self) -> MNTR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MNTR { bits }
-            }
-            #[doc = "Bits 8:11 - Minute units in BCD format"]
-            #[inline]
-            pub fn mnu(&self) -> MNUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MNUR { bits }
-            }
-            #[doc = "Bit 7 - Alarm B seconds mask"]
-            #[inline]
-            pub fn msk1(&self) -> MSK1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSK1R { bits }
-            }
-            #[doc = "Bits 4:6 - Second tens in BCD format"]
-            #[inline]
-            pub fn st(&self) -> STR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                STR { bits }
-            }
-            #[doc = "Bits 0:3 - Second units in BCD format"]
-            #[inline]
-            pub fn su(&self) -> SUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SUR { bits }
-            }
-        }
-        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 31 - Alarm B date mask"]
-            #[inline]
-            pub fn msk4(&mut self) -> _MSK4W {
-                _MSK4W { w: self }
-            }
-            #[doc = "Bit 30 - Week day selection"]
-            #[inline]
-            pub fn wdsel(&mut self) -> _WDSELW {
-                _WDSELW { w: self }
-            }
-            #[doc = "Bits 28:29 - Date tens in BCD format"]
-            #[inline]
-            pub fn dt(&mut self) -> _DTW {
-                _DTW { w: self }
-            }
-            #[doc = "Bits 24:27 - Date units or day in BCD format"]
-            #[inline]
-            pub fn du(&mut self) -> _DUW {
-                _DUW { w: self }
-            }
-            #[doc = "Bit 23 - Alarm B hours mask"]
-            #[inline]
-            pub fn msk3(&mut self) -> _MSK3W {
-                _MSK3W { w: self }
-            }
-            #[doc = "Bit 22 - AM/PM notation"]
-            #[inline]
-            pub fn pm(&mut self) -> _PMW {
-                _PMW { w: self }
-            }
-            #[doc = "Bits 20:21 - Hour tens in BCD format"]
-            #[inline]
-            pub fn ht(&mut self) -> _HTW {
-                _HTW { w: self }
-            }
-            #[doc = "Bits 16:19 - Hour units in BCD format"]
-            #[inline]
-            pub fn hu(&mut self) -> _HUW {
-                _HUW { w: self }
-            }
-            #[doc = "Bit 15 - Alarm B minutes mask"]
-            #[inline]
-            pub fn msk2(&mut self) -> _MSK2W {
-                _MSK2W { w: self }
-            }
-            #[doc = "Bits 12:14 - Minute tens in BCD format"]
-            #[inline]
-            pub fn mnt(&mut self) -> _MNTW {
-                _MNTW { w: self }
-            }
-            #[doc = "Bits 8:11 - Minute units in BCD format"]
-            #[inline]
-            pub fn mnu(&mut self) -> _MNUW {
-                _MNUW { w: self }
-            }
-            #[doc = "Bit 7 - Alarm B seconds mask"]
-            #[inline]
-            pub fn msk1(&mut self) -> _MSK1W {
-                _MSK1W { w: self }
-            }
-            #[doc = "Bits 4:6 - Second tens in BCD format"]
-            #[inline]
-            pub fn st(&mut self) -> _STW {
-                _STW { w: self }
-            }
-            #[doc = "Bits 0:3 - Second units in BCD format"]
-            #[inline]
-            pub fn su(&mut self) -> _SUW {
-                _SUW { w: self }
-            }
-        }
-    }
-    #[doc = "write protection register"]
-    pub struct WPR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "write protection register"]
-    pub mod wpr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::WPR {
-            #[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" Proxy"]
-        pub struct _KEYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _KEYW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        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 0:7 - Write protection key"]
-            #[inline]
-            pub fn key(&mut self) -> _KEYW {
-                _KEYW { w: self }
-            }
-        }
-    }
-    #[doc = "sub second register"]
-    pub struct SSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "sub second register"]
-    pub mod ssr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::SSR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SSR {
-            bits: u16,
-        }
-        impl SSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Sub second value"]
-            #[inline]
-            pub fn ss(&self) -> SSR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                SSR { bits }
-            }
-        }
-    }
-    #[doc = "shift control register"]
-    pub struct SHIFTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "shift control register"]
-    pub mod shiftr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::SHIFTR {
-            #[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" Proxy"]
-        pub struct _ADD1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADD1SW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SUBFSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SUBFSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x7fff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        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 31 - Add one second"]
-            #[inline]
-            pub fn add1s(&mut self) -> _ADD1SW {
-                _ADD1SW { w: self }
-            }
-            #[doc = "Bits 0:14 - Subtract a fraction of a second"]
-            #[inline]
-            pub fn subfs(&mut self) -> _SUBFSW {
-                _SUBFSW { w: self }
-            }
-        }
-    }
-    #[doc = "time stamp time register"]
-    pub struct TSTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "time stamp time register"]
-    pub mod tstr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::TSTR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PMR {
-            bits: bool,
-        }
-        impl PMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTR {
-            bits: u8,
-        }
-        impl HTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct HUR {
-            bits: u8,
-        }
-        impl HUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MNTR {
-            bits: u8,
-        }
-        impl MNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MNUR {
-            bits: u8,
-        }
-        impl MNUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STR {
-            bits: u8,
-        }
-        impl STR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SUR {
-            bits: u8,
-        }
-        impl SUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 22 - AM/PM notation"]
-            #[inline]
-            pub fn pm(&self) -> PMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PMR { bits }
-            }
-            #[doc = "Bits 20:21 - Hour tens in BCD format"]
-            #[inline]
-            pub fn ht(&self) -> HTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HTR { bits }
-            }
-            #[doc = "Bits 16:19 - Hour units in BCD format"]
-            #[inline]
-            pub fn hu(&self) -> HUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                HUR { bits }
-            }
-            #[doc = "Bits 12:14 - Minute tens in BCD format"]
-            #[inline]
-            pub fn mnt(&self) -> MNTR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MNTR { bits }
-            }
-            #[doc = "Bits 8:11 - Minute units in BCD format"]
-            #[inline]
-            pub fn mnu(&self) -> MNUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MNUR { bits }
-            }
-            #[doc = "Bits 4:6 - Second tens in BCD format"]
-            #[inline]
-            pub fn st(&self) -> STR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                STR { bits }
-            }
-            #[doc = "Bits 0:3 - Second units in BCD format"]
-            #[inline]
-            pub fn su(&self) -> SUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SUR { bits }
-            }
-        }
-    }
-    #[doc = "time stamp date register"]
-    pub struct TSDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "time stamp date register"]
-    pub mod tsdr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::TSDR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct WDUR {
-            bits: u8,
-        }
-        impl WDUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MTR {
-            bits: bool,
-        }
-        impl MTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUR {
-            bits: u8,
-        }
-        impl MUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTR {
-            bits: u8,
-        }
-        impl DTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DUR {
-            bits: u8,
-        }
-        impl DUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 13:15 - Week day units"]
-            #[inline]
-            pub fn wdu(&self) -> WDUR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                WDUR { bits }
-            }
-            #[doc = "Bit 12 - Month tens in BCD format"]
-            #[inline]
-            pub fn mt(&self) -> MTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MTR { bits }
-            }
-            #[doc = "Bits 8:11 - Month units in BCD format"]
-            #[inline]
-            pub fn mu(&self) -> MUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MUR { bits }
-            }
-            #[doc = "Bits 4:5 - Date tens in BCD format"]
-            #[inline]
-            pub fn dt(&self) -> DTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTR { bits }
-            }
-            #[doc = "Bits 0:3 - Date units in BCD format"]
-            #[inline]
-            pub fn du(&self) -> DUR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DUR { bits }
-            }
-        }
-    }
-    #[doc = "timestamp sub second register"]
-    pub struct TSSSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "timestamp sub second register"]
-    pub mod tsssr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::TSSSR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SSR {
-            bits: u16,
-        }
-        impl SSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Sub second value"]
-            #[inline]
-            pub fn ss(&self) -> SSR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                SSR { bits }
-            }
-        }
-    }
-    #[doc = "calibration register"]
-    pub struct CALR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "calibration register"]
-    pub mod calr {
-        #[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::CALR {
-            #[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 = r" Value of the field"]
-        pub struct CALPR {
-            bits: bool,
-        }
-        impl CALPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CALW8R {
-            bits: bool,
-        }
-        impl CALW8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CALW16R {
-            bits: bool,
-        }
-        impl CALW16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CALMR {
-            bits: u16,
-        }
-        impl CALMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CALPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CALPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CALW8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CALW8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CALW16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CALW16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CALMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CALMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x01ff;
-                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 = "Bit 15 - Increase frequency of RTC by 488.5 ppm"]
-            #[inline]
-            pub fn calp(&self) -> CALPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CALPR { bits }
-            }
-            #[doc = "Bit 14 - Use an 8-second calibration cycle period"]
-            #[inline]
-            pub fn calw8(&self) -> CALW8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CALW8R { bits }
-            }
-            #[doc = "Bit 13 - Use a 16-second calibration cycle period"]
-            #[inline]
-            pub fn calw16(&self) -> CALW16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CALW16R { bits }
-            }
-            #[doc = "Bits 0:8 - Calibration minus"]
-            #[inline]
-            pub fn calm(&self) -> CALMR {
-                let bits = {
-                    const MASK: u16 = 0x01ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CALMR { bits }
-            }
-        }
-        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 15 - Increase frequency of RTC by 488.5 ppm"]
-            #[inline]
-            pub fn calp(&mut self) -> _CALPW {
-                _CALPW { w: self }
-            }
-            #[doc = "Bit 14 - Use an 8-second calibration cycle period"]
-            #[inline]
-            pub fn calw8(&mut self) -> _CALW8W {
-                _CALW8W { w: self }
-            }
-            #[doc = "Bit 13 - Use a 16-second calibration cycle period"]
-            #[inline]
-            pub fn calw16(&mut self) -> _CALW16W {
-                _CALW16W { w: self }
-            }
-            #[doc = "Bits 0:8 - Calibration minus"]
-            #[inline]
-            pub fn calm(&mut self) -> _CALMW {
-                _CALMW { w: self }
-            }
-        }
-    }
-    #[doc = "tamper and alternate function configuration register"]
-    pub struct TAFCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "tamper and alternate function configuration register"]
-    pub mod tafcr {
-        #[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::TAFCR {
-            #[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 = r" Value of the field"]
-        pub struct ALARMOUTTYPER {
-            bits: bool,
-        }
-        impl ALARMOUTTYPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSINSELR {
-            bits: bool,
-        }
-        impl TSINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMP1INSELR {
-            bits: bool,
-        }
-        impl TAMP1INSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMPPUDISR {
-            bits: bool,
-        }
-        impl TAMPPUDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMPPRCHR {
-            bits: u8,
-        }
-        impl TAMPPRCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TAMPFLTR {
-            bits: u8,
-        }
-        impl TAMPFLTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TAMPFREQR {
-            bits: u8,
-        }
-        impl TAMPFREQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TAMPTSR {
-            bits: bool,
-        }
-        impl TAMPTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMP2TRGR {
-            bits: bool,
-        }
-        impl TAMP2TRGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMP2ER {
-            bits: bool,
-        }
-        impl TAMP2ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMPIER {
-            bits: bool,
-        }
-        impl TAMPIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMP1TRGR {
-            bits: bool,
-        }
-        impl TAMP1TRGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TAMP1ER {
-            bits: bool,
-        }
-        impl TAMP1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ALARMOUTTYPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALARMOUTTYPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMP1INSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMP1INSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMPPUDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMPPUDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMPPRCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMPPRCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TAMPFLTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMPFLTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TAMPFREQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMPFREQW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TAMPTSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMPTSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMP2TRGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMP2TRGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMP2EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMP2EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMPIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMPIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMP1TRGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMP1TRGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TAMP1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TAMP1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 18 - AFO_ALARM output type"]
-            #[inline]
-            pub fn alarmouttype(&self) -> ALARMOUTTYPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALARMOUTTYPER { bits }
-            }
-            #[doc = "Bit 17 - TIMESTAMP mapping"]
-            #[inline]
-            pub fn tsinsel(&self) -> TSINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TSINSELR { bits }
-            }
-            #[doc = "Bit 16 - TAMPER1 mapping"]
-            #[inline]
-            pub fn tamp1insel(&self) -> TAMP1INSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMP1INSELR { bits }
-            }
-            #[doc = "Bit 15 - TAMPER pull-up disable"]
-            #[inline]
-            pub fn tamppudis(&self) -> TAMPPUDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMPPUDISR { bits }
-            }
-            #[doc = "Bits 13:14 - Tamper precharge duration"]
-            #[inline]
-            pub fn tampprch(&self) -> TAMPPRCHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TAMPPRCHR { bits }
-            }
-            #[doc = "Bits 11:12 - Tamper filter count"]
-            #[inline]
-            pub fn tampflt(&self) -> TAMPFLTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TAMPFLTR { bits }
-            }
-            #[doc = "Bits 8:10 - Tamper sampling frequency"]
-            #[inline]
-            pub fn tampfreq(&self) -> TAMPFREQR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TAMPFREQR { bits }
-            }
-            #[doc = "Bit 7 - Activate timestamp on tamper detection event"]
-            #[inline]
-            pub fn tampts(&self) -> TAMPTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMPTSR { bits }
-            }
-            #[doc = "Bit 4 - Active level for tamper 2"]
-            #[inline]
-            pub fn tamp2trg(&self) -> TAMP2TRGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMP2TRGR { bits }
-            }
-            #[doc = "Bit 3 - Tamper 2 detection enable"]
-            #[inline]
-            pub fn tamp2e(&self) -> TAMP2ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMP2ER { bits }
-            }
-            #[doc = "Bit 2 - Tamper interrupt enable"]
-            #[inline]
-            pub fn tampie(&self) -> TAMPIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMPIER { bits }
-            }
-            #[doc = "Bit 1 - Active level for tamper 1"]
-            #[inline]
-            pub fn tamp1trg(&self) -> TAMP1TRGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMP1TRGR { bits }
-            }
-            #[doc = "Bit 0 - Tamper 1 detection enable"]
-            #[inline]
-            pub fn tamp1e(&self) -> TAMP1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TAMP1ER { bits }
-            }
-        }
-        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 18 - AFO_ALARM output type"]
-            #[inline]
-            pub fn alarmouttype(&mut self) -> _ALARMOUTTYPEW {
-                _ALARMOUTTYPEW { w: self }
-            }
-            #[doc = "Bit 17 - TIMESTAMP mapping"]
-            #[inline]
-            pub fn tsinsel(&mut self) -> _TSINSELW {
-                _TSINSELW { w: self }
-            }
-            #[doc = "Bit 16 - TAMPER1 mapping"]
-            #[inline]
-            pub fn tamp1insel(&mut self) -> _TAMP1INSELW {
-                _TAMP1INSELW { w: self }
-            }
-            #[doc = "Bit 15 - TAMPER pull-up disable"]
-            #[inline]
-            pub fn tamppudis(&mut self) -> _TAMPPUDISW {
-                _TAMPPUDISW { w: self }
-            }
-            #[doc = "Bits 13:14 - Tamper precharge duration"]
-            #[inline]
-            pub fn tampprch(&mut self) -> _TAMPPRCHW {
-                _TAMPPRCHW { w: self }
-            }
-            #[doc = "Bits 11:12 - Tamper filter count"]
-            #[inline]
-            pub fn tampflt(&mut self) -> _TAMPFLTW {
-                _TAMPFLTW { w: self }
-            }
-            #[doc = "Bits 8:10 - Tamper sampling frequency"]
-            #[inline]
-            pub fn tampfreq(&mut self) -> _TAMPFREQW {
-                _TAMPFREQW { w: self }
-            }
-            #[doc = "Bit 7 - Activate timestamp on tamper detection event"]
-            #[inline]
-            pub fn tampts(&mut self) -> _TAMPTSW {
-                _TAMPTSW { w: self }
-            }
-            #[doc = "Bit 4 - Active level for tamper 2"]
-            #[inline]
-            pub fn tamp2trg(&mut self) -> _TAMP2TRGW {
-                _TAMP2TRGW { w: self }
-            }
-            #[doc = "Bit 3 - Tamper 2 detection enable"]
-            #[inline]
-            pub fn tamp2e(&mut self) -> _TAMP2EW {
-                _TAMP2EW { w: self }
-            }
-            #[doc = "Bit 2 - Tamper interrupt enable"]
-            #[inline]
-            pub fn tampie(&mut self) -> _TAMPIEW {
-                _TAMPIEW { w: self }
-            }
-            #[doc = "Bit 1 - Active level for tamper 1"]
-            #[inline]
-            pub fn tamp1trg(&mut self) -> _TAMP1TRGW {
-                _TAMP1TRGW { w: self }
-            }
-            #[doc = "Bit 0 - Tamper 1 detection enable"]
-            #[inline]
-            pub fn tamp1e(&mut self) -> _TAMP1EW {
-                _TAMP1EW { w: self }
-            }
-        }
-    }
-    #[doc = "alarm A sub second register"]
-    pub struct ALRMASSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "alarm A sub second register"]
-    pub mod alrmassr {
-        #[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::ALRMASSR {
-            #[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 = r" Value of the field"]
-        pub struct MASKSSR {
-            bits: u8,
-        }
-        impl MASKSSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SSR {
-            bits: u16,
-        }
-        impl SSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MASKSSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MASKSSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x7fff;
-                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 24:27 - Mask the most-significant bits starting at this bit"]
-            #[inline]
-            pub fn maskss(&self) -> MASKSSR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MASKSSR { bits }
-            }
-            #[doc = "Bits 0:14 - Sub seconds value"]
-            #[inline]
-            pub fn ss(&self) -> SSR {
-                let bits = {
-                    const MASK: u16 = 0x7fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                SSR { bits }
-            }
-        }
-        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 24:27 - Mask the most-significant bits starting at this bit"]
-            #[inline]
-            pub fn maskss(&mut self) -> _MASKSSW {
-                _MASKSSW { w: self }
-            }
-            #[doc = "Bits 0:14 - Sub seconds value"]
-            #[inline]
-            pub fn ss(&mut self) -> _SSW {
-                _SSW { w: self }
-            }
-        }
-    }
-    #[doc = "alarm B sub second register"]
-    pub struct ALRMBSSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "alarm B sub second register"]
-    pub mod alrmbssr {
-        #[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::ALRMBSSR {
-            #[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 = r" Value of the field"]
-        pub struct MASKSSR {
-            bits: u8,
-        }
-        impl MASKSSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SSR {
-            bits: u16,
-        }
-        impl SSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MASKSSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MASKSSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x7fff;
-                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 24:27 - Mask the most-significant bits starting at this bit"]
-            #[inline]
-            pub fn maskss(&self) -> MASKSSR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MASKSSR { bits }
-            }
-            #[doc = "Bits 0:14 - Sub seconds value"]
-            #[inline]
-            pub fn ss(&self) -> SSR {
-                let bits = {
-                    const MASK: u16 = 0x7fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                SSR { bits }
-            }
-        }
-        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 24:27 - Mask the most-significant bits starting at this bit"]
-            #[inline]
-            pub fn maskss(&mut self) -> _MASKSSW {
-                _MASKSSW { w: self }
-            }
-            #[doc = "Bits 0:14 - Sub seconds value"]
-            #[inline]
-            pub fn ss(&mut self) -> _SSW {
-                _SSW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp0r {
-        #[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::BKP0R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp1r {
-        #[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::BKP1R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP2R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp2r {
-        #[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::BKP2R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP3R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp3r {
-        #[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::BKP3R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP4R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp4r {
-        #[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::BKP4R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP5R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp5r {
-        #[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::BKP5R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP6R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp6r {
-        #[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::BKP6R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP7R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp7r {
-        #[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::BKP7R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP8R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp8r {
-        #[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::BKP8R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP9R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp9r {
-        #[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::BKP9R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP10R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp10r {
-        #[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::BKP10R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP11R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp11r {
-        #[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::BKP11R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP12R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp12r {
-        #[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::BKP12R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP13R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp13r {
-        #[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::BKP13R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP14R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp14r {
-        #[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::BKP14R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP15R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp15r {
-        #[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::BKP15R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP16R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp16r {
-        #[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::BKP16R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP17R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp17r {
-        #[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::BKP17R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP18R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp18r {
-        #[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::BKP18R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-    #[doc = "backup register"]
-    pub struct BKP19R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "backup register"]
-    pub mod bkp19r {
-        #[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::BKP19R {
-            #[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 = r" Value of the field"]
-        pub struct BKPR {
-            bits: u32,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                BKPR { bits }
-            }
-        }
-        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 0:31 - BKP"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-        }
-    }
-}
-#[doc = "Secure digital input/output interface"]
-pub struct SDIO {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for SDIO {}
-impl SDIO {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const sdio::RegisterBlock {
-        0x4001_2c00 as *const _
-    }
-}
-impl Deref for SDIO {
-    type Target = sdio::RegisterBlock;
-    fn deref(&self) -> &sdio::RegisterBlock {
-        unsafe { &*SDIO::ptr() }
-    }
-}
-#[doc = "Secure digital input/output interface"]
-pub mod sdio {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - power control register"]
-        pub power: POWER,
-        #[doc = "0x04 - SDI clock control register"]
-        pub clkcr: CLKCR,
-        #[doc = "0x08 - argument register"]
-        pub arg: ARG,
-        #[doc = "0x0c - command register"]
-        pub cmd: CMD,
-        #[doc = "0x10 - command response register"]
-        pub respcmd: RESPCMD,
-        #[doc = "0x14 - response 1..4 register"]
-        pub resp1: RESP1,
-        #[doc = "0x18 - response 1..4 register"]
-        pub resp2: RESP2,
-        #[doc = "0x1c - response 1..4 register"]
-        pub resp3: RESP3,
-        #[doc = "0x20 - response 1..4 register"]
-        pub resp4: RESP4,
-        #[doc = "0x24 - data timer register"]
-        pub dtimer: DTIMER,
-        #[doc = "0x28 - data length register"]
-        pub dlen: DLEN,
-        #[doc = "0x2c - data control register"]
-        pub dctrl: DCTRL,
-        #[doc = "0x30 - data counter register"]
-        pub dcount: DCOUNT,
-        #[doc = "0x34 - status register"]
-        pub sta: STA,
-        #[doc = "0x38 - interrupt clear register"]
-        pub icr: ICR,
-        #[doc = "0x3c - mask register"]
-        pub mask: MASK,
-        _reserved0: [u8; 8usize],
-        #[doc = "0x48 - FIFO counter register"]
-        pub fifocnt: FIFOCNT,
-        _reserved1: [u8; 52usize],
-        #[doc = "0x80 - data FIFO register"]
-        pub fifo: FIFO,
-    }
-    #[doc = "power control register"]
-    pub struct POWER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "power control register"]
-    pub mod power {
-        #[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::POWER {
-            #[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 = r" Value of the field"]
-        pub struct PWRCTRLR {
-            bits: u8,
-        }
-        impl PWRCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PWRCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWRCTRLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 0:1 - PWRCTRL"]
-            #[inline]
-            pub fn pwrctrl(&self) -> PWRCTRLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PWRCTRLR { bits }
-            }
-        }
-        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 0:1 - PWRCTRL"]
-            #[inline]
-            pub fn pwrctrl(&mut self) -> _PWRCTRLW {
-                _PWRCTRLW { w: self }
-            }
-        }
-    }
-    #[doc = "SDI clock control register"]
-    pub struct CLKCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SDI clock control register"]
-    pub mod clkcr {
-        #[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::CLKCR {
-            #[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 = r" Value of the field"]
-        pub struct HWFC_ENR {
-            bits: bool,
-        }
-        impl HWFC_ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NEGEDGER {
-            bits: bool,
-        }
-        impl NEGEDGER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WIDBUSR {
-            bits: u8,
-        }
-        impl WIDBUSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BYPASSR {
-            bits: bool,
-        }
-        impl BYPASSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWRSAVR {
-            bits: bool,
-        }
-        impl PWRSAVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CLKENR {
-            bits: bool,
-        }
-        impl CLKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HWFC_ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HWFC_ENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NEGEDGEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NEGEDGEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WIDBUSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WIDBUSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BYPASSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BYPASSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWRSAVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWRSAVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CLKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 = "Bit 14 - HW Flow Control enable"]
-            #[inline]
-            pub fn hwfc_en(&self) -> HWFC_ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HWFC_ENR { bits }
-            }
-            #[doc = "Bit 13 - SDIO_CK dephasing selection bit"]
-            #[inline]
-            pub fn negedge(&self) -> NEGEDGER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NEGEDGER { bits }
-            }
-            #[doc = "Bits 11:12 - Wide bus mode enable bit"]
-            #[inline]
-            pub fn widbus(&self) -> WIDBUSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                WIDBUSR { bits }
-            }
-            #[doc = "Bit 10 - Clock divider bypass enable bit"]
-            #[inline]
-            pub fn bypass(&self) -> BYPASSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BYPASSR { bits }
-            }
-            #[doc = "Bit 9 - Power saving configuration bit"]
-            #[inline]
-            pub fn pwrsav(&self) -> PWRSAVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PWRSAVR { bits }
-            }
-            #[doc = "Bit 8 - Clock enable bit"]
-            #[inline]
-            pub fn clken(&self) -> CLKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLKENR { bits }
-            }
-            #[doc = "Bits 0:7 - Clock divide factor"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-        }
-        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 14 - HW Flow Control enable"]
-            #[inline]
-            pub fn hwfc_en(&mut self) -> _HWFC_ENW {
-                _HWFC_ENW { w: self }
-            }
-            #[doc = "Bit 13 - SDIO_CK dephasing selection bit"]
-            #[inline]
-            pub fn negedge(&mut self) -> _NEGEDGEW {
-                _NEGEDGEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Wide bus mode enable bit"]
-            #[inline]
-            pub fn widbus(&mut self) -> _WIDBUSW {
-                _WIDBUSW { w: self }
-            }
-            #[doc = "Bit 10 - Clock divider bypass enable bit"]
-            #[inline]
-            pub fn bypass(&mut self) -> _BYPASSW {
-                _BYPASSW { w: self }
-            }
-            #[doc = "Bit 9 - Power saving configuration bit"]
-            #[inline]
-            pub fn pwrsav(&mut self) -> _PWRSAVW {
-                _PWRSAVW { w: self }
-            }
-            #[doc = "Bit 8 - Clock enable bit"]
-            #[inline]
-            pub fn clken(&mut self) -> _CLKENW {
-                _CLKENW { w: self }
-            }
-            #[doc = "Bits 0:7 - Clock divide factor"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-        }
-    }
-    #[doc = "argument register"]
-    pub struct ARG {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "argument register"]
-    pub mod arg {
-        #[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::ARG {
-            #[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 = r" Value of the field"]
-        pub struct CMDARGR {
-            bits: u32,
-        }
-        impl CMDARGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CMDARGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMDARGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Command argument"]
-            #[inline]
-            pub fn cmdarg(&self) -> CMDARGR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CMDARGR { bits }
-            }
-        }
-        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 0:31 - Command argument"]
-            #[inline]
-            pub fn cmdarg(&mut self) -> _CMDARGW {
-                _CMDARGW { w: self }
-            }
-        }
-    }
-    #[doc = "command register"]
-    pub struct CMD {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "command register"]
-    pub mod cmd {
-        #[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::CMD {
-            #[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 = r" Value of the field"]
-        pub struct CE_ATACMDR {
-            bits: bool,
-        }
-        impl CE_ATACMDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NIENR {
-            bits: bool,
-        }
-        impl NIENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENCMDCOMPLR {
-            bits: bool,
-        }
-        impl ENCMDCOMPLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDIOSUSPENDR {
-            bits: bool,
-        }
-        impl SDIOSUSPENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CPSMENR {
-            bits: bool,
-        }
-        impl CPSMENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITPENDR {
-            bits: bool,
-        }
-        impl WAITPENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITINTR {
-            bits: bool,
-        }
-        impl WAITINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITRESPR {
-            bits: u8,
-        }
-        impl WAITRESPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CMDINDEXR {
-            bits: u8,
-        }
-        impl CMDINDEXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CE_ATACMDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CE_ATACMDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NIENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NIENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENCMDCOMPLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENCMDCOMPLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDIOSUSPENDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDIOSUSPENDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CPSMENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CPSMENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITPENDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITPENDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITINTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITRESPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITRESPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CMDINDEXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMDINDEXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x3f;
-                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 = "Bit 14 - CE-ATA command"]
-            #[inline]
-            pub fn ce_atacmd(&self) -> CE_ATACMDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CE_ATACMDR { bits }
-            }
-            #[doc = "Bit 13 - not Interrupt Enable"]
-            #[inline]
-            pub fn n_ien(&self) -> NIENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NIENR { bits }
-            }
-            #[doc = "Bit 12 - Enable CMD completion"]
-            #[inline]
-            pub fn encmdcompl(&self) -> ENCMDCOMPLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENCMDCOMPLR { bits }
-            }
-            #[doc = "Bit 11 - SD I/O suspend command"]
-            #[inline]
-            pub fn sdiosuspend(&self) -> SDIOSUSPENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDIOSUSPENDR { bits }
-            }
-            #[doc = "Bit 10 - Command path state machine (CPSM) Enable bit"]
-            #[inline]
-            pub fn cpsmen(&self) -> CPSMENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CPSMENR { bits }
-            }
-            #[doc = "Bit 9 - CPSM Waits for ends of data transfer (CmdPend internal signal)."]
-            #[inline]
-            pub fn waitpend(&self) -> WAITPENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITPENDR { bits }
-            }
-            #[doc = "Bit 8 - CPSM waits for interrupt request"]
-            #[inline]
-            pub fn waitint(&self) -> WAITINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITINTR { bits }
-            }
-            #[doc = "Bits 6:7 - Wait for response bits"]
-            #[inline]
-            pub fn waitresp(&self) -> WAITRESPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                WAITRESPR { bits }
-            }
-            #[doc = "Bits 0:5 - Command index"]
-            #[inline]
-            pub fn cmdindex(&self) -> CMDINDEXR {
-                let bits = {
-                    const MASK: u8 = 0x3f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CMDINDEXR { bits }
-            }
-        }
-        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 14 - CE-ATA command"]
-            #[inline]
-            pub fn ce_atacmd(&mut self) -> _CE_ATACMDW {
-                _CE_ATACMDW { w: self }
-            }
-            #[doc = "Bit 13 - not Interrupt Enable"]
-            #[inline]
-            pub fn n_ien(&mut self) -> _NIENW {
-                _NIENW { w: self }
-            }
-            #[doc = "Bit 12 - Enable CMD completion"]
-            #[inline]
-            pub fn encmdcompl(&mut self) -> _ENCMDCOMPLW {
-                _ENCMDCOMPLW { w: self }
-            }
-            #[doc = "Bit 11 - SD I/O suspend command"]
-            #[inline]
-            pub fn sdiosuspend(&mut self) -> _SDIOSUSPENDW {
-                _SDIOSUSPENDW { w: self }
-            }
-            #[doc = "Bit 10 - Command path state machine (CPSM) Enable bit"]
-            #[inline]
-            pub fn cpsmen(&mut self) -> _CPSMENW {
-                _CPSMENW { w: self }
-            }
-            #[doc = "Bit 9 - CPSM Waits for ends of data transfer (CmdPend internal signal)."]
-            #[inline]
-            pub fn waitpend(&mut self) -> _WAITPENDW {
-                _WAITPENDW { w: self }
-            }
-            #[doc = "Bit 8 - CPSM waits for interrupt request"]
-            #[inline]
-            pub fn waitint(&mut self) -> _WAITINTW {
-                _WAITINTW { w: self }
-            }
-            #[doc = "Bits 6:7 - Wait for response bits"]
-            #[inline]
-            pub fn waitresp(&mut self) -> _WAITRESPW {
-                _WAITRESPW { w: self }
-            }
-            #[doc = "Bits 0:5 - Command index"]
-            #[inline]
-            pub fn cmdindex(&mut self) -> _CMDINDEXW {
-                _CMDINDEXW { w: self }
-            }
-        }
-    }
-    #[doc = "command response register"]
-    pub struct RESPCMD {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "command response register"]
-    pub mod respcmd {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RESPCMD {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RESPCMDR {
-            bits: u8,
-        }
-        impl RESPCMDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:5 - Response command index"]
-            #[inline]
-            pub fn respcmd(&self) -> RESPCMDR {
-                let bits = {
-                    const MASK: u8 = 0x3f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RESPCMDR { bits }
-            }
-        }
-    }
-    #[doc = "response 1..4 register"]
-    pub struct RESP1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "response 1..4 register"]
-    pub mod resp1 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RESP1 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CARDSTATUS1R {
-            bits: u32,
-        }
-        impl CARDSTATUS1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:31 - Card Status"]
-            #[inline]
-            pub fn cardstatus1(&self) -> CARDSTATUS1R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CARDSTATUS1R { bits }
-            }
-        }
-    }
-    #[doc = "response 1..4 register"]
-    pub struct RESP2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "response 1..4 register"]
-    pub mod resp2 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RESP2 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CARDSTATUS2R {
-            bits: u32,
-        }
-        impl CARDSTATUS2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:31 - Card Status"]
-            #[inline]
-            pub fn cardstatus2(&self) -> CARDSTATUS2R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CARDSTATUS2R { bits }
-            }
-        }
-    }
-    #[doc = "response 1..4 register"]
-    pub struct RESP3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "response 1..4 register"]
-    pub mod resp3 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RESP3 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CARDSTATUS3R {
-            bits: u32,
-        }
-        impl CARDSTATUS3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:31 - Card Status"]
-            #[inline]
-            pub fn cardstatus3(&self) -> CARDSTATUS3R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CARDSTATUS3R { bits }
-            }
-        }
-    }
-    #[doc = "response 1..4 register"]
-    pub struct RESP4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "response 1..4 register"]
-    pub mod resp4 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RESP4 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CARDSTATUS4R {
-            bits: u32,
-        }
-        impl CARDSTATUS4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:31 - Card Status"]
-            #[inline]
-            pub fn cardstatus4(&self) -> CARDSTATUS4R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CARDSTATUS4R { bits }
-            }
-        }
-    }
-    #[doc = "data timer register"]
-    pub struct DTIMER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data timer register"]
-    pub mod dtimer {
-        #[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::DTIMER {
-            #[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 = r" Value of the field"]
-        pub struct DATATIMER {
-            bits: u32,
-        }
-        impl DATATIMER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATATIMEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATATIMEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Data timeout period"]
-            #[inline]
-            pub fn datatime(&self) -> DATATIMER {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                DATATIMER { bits }
-            }
-        }
-        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 0:31 - Data timeout period"]
-            #[inline]
-            pub fn datatime(&mut self) -> _DATATIMEW {
-                _DATATIMEW { w: self }
-            }
-        }
-    }
-    #[doc = "data length register"]
-    pub struct DLEN {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data length register"]
-    pub mod dlen {
-        #[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::DLEN {
-            #[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 = r" Value of the field"]
-        pub struct DATALENGTHR {
-            bits: u32,
-        }
-        impl DATALENGTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATALENGTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATALENGTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x01ff_ffff;
-                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 0:24 - Data length value"]
-            #[inline]
-            pub fn datalength(&self) -> DATALENGTHR {
-                let bits = {
-                    const MASK: u32 = 0x01ff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                DATALENGTHR { bits }
-            }
-        }
-        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 0:24 - Data length value"]
-            #[inline]
-            pub fn datalength(&mut self) -> _DATALENGTHW {
-                _DATALENGTHW { w: self }
-            }
-        }
-    }
-    #[doc = "data control register"]
-    pub struct DCTRL {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data control register"]
-    pub mod dctrl {
-        #[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::DCTRL {
-            #[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 = r" Value of the field"]
-        pub struct SDIOENR {
-            bits: bool,
-        }
-        impl SDIOENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RWMODR {
-            bits: bool,
-        }
-        impl RWMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RWSTOPR {
-            bits: bool,
-        }
-        impl RWSTOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RWSTARTR {
-            bits: bool,
-        }
-        impl RWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBLOCKSIZER {
-            bits: u8,
-        }
-        impl DBLOCKSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMAENR {
-            bits: bool,
-        }
-        impl DMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTMODER {
-            bits: bool,
-        }
-        impl DTMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTDIRR {
-            bits: bool,
-        }
-        impl DTDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTENR {
-            bits: bool,
-        }
-        impl DTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SDIOENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDIOENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RWMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RWMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RWSTOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RWSTOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBLOCKSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBLOCKSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTMODEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 11 - SD I/O enable functions"]
-            #[inline]
-            pub fn sdioen(&self) -> SDIOENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDIOENR { bits }
-            }
-            #[doc = "Bit 10 - Read wait mode"]
-            #[inline]
-            pub fn rwmod(&self) -> RWMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RWMODR { bits }
-            }
-            #[doc = "Bit 9 - Read wait stop"]
-            #[inline]
-            pub fn rwstop(&self) -> RWSTOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RWSTOPR { bits }
-            }
-            #[doc = "Bit 8 - Read wait start"]
-            #[inline]
-            pub fn rwstart(&self) -> RWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RWSTARTR { bits }
-            }
-            #[doc = "Bits 4:7 - Data block size"]
-            #[inline]
-            pub fn dblocksize(&self) -> DBLOCKSIZER {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBLOCKSIZER { bits }
-            }
-            #[doc = "Bit 3 - DMA enable bit"]
-            #[inline]
-            pub fn dmaen(&self) -> DMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAENR { bits }
-            }
-            # [ doc = "Bit 2 - Data transfer mode selection 1: Stream or SDIO multibyte data transfer." ] # [ inline ]
-            pub fn dtmode(&self) -> DTMODER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTMODER { bits }
-            }
-            #[doc = "Bit 1 - Data transfer direction selection"]
-            #[inline]
-            pub fn dtdir(&self) -> DTDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTDIRR { bits }
-            }
-            #[doc = "Bit 0 - DTEN"]
-            #[inline]
-            pub fn dten(&self) -> DTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTENR { bits }
-            }
-        }
-        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 11 - SD I/O enable functions"]
-            #[inline]
-            pub fn sdioen(&mut self) -> _SDIOENW {
-                _SDIOENW { w: self }
-            }
-            #[doc = "Bit 10 - Read wait mode"]
-            #[inline]
-            pub fn rwmod(&mut self) -> _RWMODW {
-                _RWMODW { w: self }
-            }
-            #[doc = "Bit 9 - Read wait stop"]
-            #[inline]
-            pub fn rwstop(&mut self) -> _RWSTOPW {
-                _RWSTOPW { w: self }
-            }
-            #[doc = "Bit 8 - Read wait start"]
-            #[inline]
-            pub fn rwstart(&mut self) -> _RWSTARTW {
-                _RWSTARTW { w: self }
-            }
-            #[doc = "Bits 4:7 - Data block size"]
-            #[inline]
-            pub fn dblocksize(&mut self) -> _DBLOCKSIZEW {
-                _DBLOCKSIZEW { w: self }
-            }
-            #[doc = "Bit 3 - DMA enable bit"]
-            #[inline]
-            pub fn dmaen(&mut self) -> _DMAENW {
-                _DMAENW { w: self }
-            }
-            # [ doc = "Bit 2 - Data transfer mode selection 1: Stream or SDIO multibyte data transfer." ] # [ inline ]
-            pub fn dtmode(&mut self) -> _DTMODEW {
-                _DTMODEW { w: self }
-            }
-            #[doc = "Bit 1 - Data transfer direction selection"]
-            #[inline]
-            pub fn dtdir(&mut self) -> _DTDIRW {
-                _DTDIRW { w: self }
-            }
-            #[doc = "Bit 0 - DTEN"]
-            #[inline]
-            pub fn dten(&mut self) -> _DTENW {
-                _DTENW { w: self }
-            }
-        }
-    }
-    #[doc = "data counter register"]
-    pub struct DCOUNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data counter register"]
-    pub mod dcount {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DCOUNT {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATACOUNTR {
-            bits: u32,
-        }
-        impl DATACOUNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:24 - Data count value"]
-            #[inline]
-            pub fn datacount(&self) -> DATACOUNTR {
-                let bits = {
-                    const MASK: u32 = 0x01ff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                DATACOUNTR { bits }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct STA {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sta {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::STA {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CEATAENDR {
-            bits: bool,
-        }
-        impl CEATAENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDIOITR {
-            bits: bool,
-        }
-        impl SDIOITR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXDAVLR {
-            bits: bool,
-        }
-        impl RXDAVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXDAVLR {
-            bits: bool,
-        }
-        impl TXDAVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFIFOER {
-            bits: bool,
-        }
-        impl RXFIFOER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFIFOER {
-            bits: bool,
-        }
-        impl TXFIFOER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFIFOFR {
-            bits: bool,
-        }
-        impl RXFIFOFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFIFOFR {
-            bits: bool,
-        }
-        impl TXFIFOFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFIFOHFR {
-            bits: bool,
-        }
-        impl RXFIFOHFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFIFOHER {
-            bits: bool,
-        }
-        impl TXFIFOHER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXACTR {
-            bits: bool,
-        }
-        impl RXACTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXACTR {
-            bits: bool,
-        }
-        impl TXACTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMDACTR {
-            bits: bool,
-        }
-        impl CMDACTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBCKENDR {
-            bits: bool,
-        }
-        impl DBCKENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STBITERRR {
-            bits: bool,
-        }
-        impl STBITERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DATAENDR {
-            bits: bool,
-        }
-        impl DATAENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMDSENTR {
-            bits: bool,
-        }
-        impl CMDSENTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMDRENDR {
-            bits: bool,
-        }
-        impl CMDRENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXOVERRR {
-            bits: bool,
-        }
-        impl RXOVERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXUNDERRR {
-            bits: bool,
-        }
-        impl TXUNDERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTIMEOUTR {
-            bits: bool,
-        }
-        impl DTIMEOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTIMEOUTR {
-            bits: bool,
-        }
-        impl CTIMEOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DCRCFAILR {
-            bits: bool,
-        }
-        impl DCRCFAILR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCRCFAILR {
-            bits: bool,
-        }
-        impl CCRCFAILR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 23 - CE-ATA command completion signal received for CMD61"]
-            #[inline]
-            pub fn ceataend(&self) -> CEATAENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CEATAENDR { bits }
-            }
-            #[doc = "Bit 22 - SDIO interrupt received"]
-            #[inline]
-            pub fn sdioit(&self) -> SDIOITR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDIOITR { bits }
-            }
-            #[doc = "Bit 21 - Data available in receive FIFO"]
-            #[inline]
-            pub fn rxdavl(&self) -> RXDAVLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXDAVLR { bits }
-            }
-            #[doc = "Bit 20 - Data available in transmit FIFO"]
-            #[inline]
-            pub fn txdavl(&self) -> TXDAVLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXDAVLR { bits }
-            }
-            #[doc = "Bit 19 - Receive FIFO empty"]
-            #[inline]
-            pub fn rxfifoe(&self) -> RXFIFOER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFIFOER { bits }
-            }
-            #[doc = "Bit 18 - Transmit FIFO empty"]
-            #[inline]
-            pub fn txfifoe(&self) -> TXFIFOER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFIFOER { bits }
-            }
-            #[doc = "Bit 17 - Receive FIFO full"]
-            #[inline]
-            pub fn rxfifof(&self) -> RXFIFOFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFIFOFR { bits }
-            }
-            #[doc = "Bit 16 - Transmit FIFO full"]
-            #[inline]
-            pub fn txfifof(&self) -> TXFIFOFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFIFOFR { bits }
-            }
-            #[doc = "Bit 15 - Receive FIFO half full: there are at least 8 words in the FIFO"]
-            #[inline]
-            pub fn rxfifohf(&self) -> RXFIFOHFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFIFOHFR { bits }
-            }
-            # [ doc = "Bit 14 - Transmit FIFO half empty: at least 8 words can be written into the FIFO" ] # [ inline ]
-            pub fn txfifohe(&self) -> TXFIFOHER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFIFOHER { bits }
-            }
-            #[doc = "Bit 13 - Data receive in progress"]
-            #[inline]
-            pub fn rxact(&self) -> RXACTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXACTR { bits }
-            }
-            #[doc = "Bit 12 - Data transmit in progress"]
-            #[inline]
-            pub fn txact(&self) -> TXACTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXACTR { bits }
-            }
-            #[doc = "Bit 11 - Command transfer in progress"]
-            #[inline]
-            pub fn cmdact(&self) -> CMDACTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMDACTR { bits }
-            }
-            #[doc = "Bit 10 - Data block sent/received (CRC check passed)"]
-            #[inline]
-            pub fn dbckend(&self) -> DBCKENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBCKENDR { bits }
-            }
-            #[doc = "Bit 9 - Start bit not detected on all data signals in wide bus mode"]
-            #[inline]
-            pub fn stbiterr(&self) -> STBITERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STBITERRR { bits }
-            }
-            #[doc = "Bit 8 - Data end (data counter, SDIDCOUNT, is zero)"]
-            #[inline]
-            pub fn dataend(&self) -> DATAENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DATAENDR { bits }
-            }
-            #[doc = "Bit 7 - Command sent (no response required)"]
-            #[inline]
-            pub fn cmdsent(&self) -> CMDSENTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMDSENTR { bits }
-            }
-            #[doc = "Bit 6 - Command response received (CRC check passed)"]
-            #[inline]
-            pub fn cmdrend(&self) -> CMDRENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMDRENDR { bits }
-            }
-            #[doc = "Bit 5 - Received FIFO overrun error"]
-            #[inline]
-            pub fn rxoverr(&self) -> RXOVERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXOVERRR { bits }
-            }
-            #[doc = "Bit 4 - Transmit FIFO underrun error"]
-            #[inline]
-            pub fn txunderr(&self) -> TXUNDERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXUNDERRR { bits }
-            }
-            #[doc = "Bit 3 - Data timeout"]
-            #[inline]
-            pub fn dtimeout(&self) -> DTIMEOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTIMEOUTR { bits }
-            }
-            #[doc = "Bit 2 - Command response timeout"]
-            #[inline]
-            pub fn ctimeout(&self) -> CTIMEOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTIMEOUTR { bits }
-            }
-            #[doc = "Bit 1 - Data block sent/received (CRC check failed)"]
-            #[inline]
-            pub fn dcrcfail(&self) -> DCRCFAILR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCRCFAILR { bits }
-            }
-            #[doc = "Bit 0 - Command response received (CRC check failed)"]
-            #[inline]
-            pub fn ccrcfail(&self) -> CCRCFAILR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCRCFAILR { bits }
-            }
-        }
-    }
-    #[doc = "interrupt clear register"]
-    pub struct ICR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt clear register"]
-    pub mod icr {
-        #[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::ICR {
-            #[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 = r" Value of the field"]
-        pub struct CEATAENDCR {
-            bits: bool,
-        }
-        impl CEATAENDCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDIOITCR {
-            bits: bool,
-        }
-        impl SDIOITCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBCKENDCR {
-            bits: bool,
-        }
-        impl DBCKENDCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STBITERRCR {
-            bits: bool,
-        }
-        impl STBITERRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DATAENDCR {
-            bits: bool,
-        }
-        impl DATAENDCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMDSENTCR {
-            bits: bool,
-        }
-        impl CMDSENTCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMDRENDCR {
-            bits: bool,
-        }
-        impl CMDRENDCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXOVERRCR {
-            bits: bool,
-        }
-        impl RXOVERRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXUNDERRCR {
-            bits: bool,
-        }
-        impl TXUNDERRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTIMEOUTCR {
-            bits: bool,
-        }
-        impl DTIMEOUTCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTIMEOUTCR {
-            bits: bool,
-        }
-        impl CTIMEOUTCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DCRCFAILCR {
-            bits: bool,
-        }
-        impl DCRCFAILCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCRCFAILCR {
-            bits: bool,
-        }
-        impl CCRCFAILCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CEATAENDCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CEATAENDCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDIOITCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDIOITCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBCKENDCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBCKENDCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STBITERRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STBITERRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DATAENDCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATAENDCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMDSENTCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMDSENTCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMDRENDCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMDRENDCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXOVERRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXOVERRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXUNDERRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXUNDERRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTIMEOUTCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTIMEOUTCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTIMEOUTCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTIMEOUTCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DCRCFAILCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCRCFAILCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CCRCFAILCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCRCFAILCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 23 - CEATAEND flag clear bit"]
-            #[inline]
-            pub fn ceataendc(&self) -> CEATAENDCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CEATAENDCR { bits }
-            }
-            #[doc = "Bit 22 - SDIOIT flag clear bit"]
-            #[inline]
-            pub fn sdioitc(&self) -> SDIOITCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDIOITCR { bits }
-            }
-            #[doc = "Bit 10 - DBCKEND flag clear bit"]
-            #[inline]
-            pub fn dbckendc(&self) -> DBCKENDCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBCKENDCR { bits }
-            }
-            #[doc = "Bit 9 - STBITERR flag clear bit"]
-            #[inline]
-            pub fn stbiterrc(&self) -> STBITERRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STBITERRCR { bits }
-            }
-            #[doc = "Bit 8 - DATAEND flag clear bit"]
-            #[inline]
-            pub fn dataendc(&self) -> DATAENDCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DATAENDCR { bits }
-            }
-            #[doc = "Bit 7 - CMDSENT flag clear bit"]
-            #[inline]
-            pub fn cmdsentc(&self) -> CMDSENTCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMDSENTCR { bits }
-            }
-            #[doc = "Bit 6 - CMDREND flag clear bit"]
-            #[inline]
-            pub fn cmdrendc(&self) -> CMDRENDCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMDRENDCR { bits }
-            }
-            #[doc = "Bit 5 - RXOVERR flag clear bit"]
-            #[inline]
-            pub fn rxoverrc(&self) -> RXOVERRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXOVERRCR { bits }
-            }
-            #[doc = "Bit 4 - TXUNDERR flag clear bit"]
-            #[inline]
-            pub fn txunderrc(&self) -> TXUNDERRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXUNDERRCR { bits }
-            }
-            #[doc = "Bit 3 - DTIMEOUT flag clear bit"]
-            #[inline]
-            pub fn dtimeoutc(&self) -> DTIMEOUTCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTIMEOUTCR { bits }
-            }
-            #[doc = "Bit 2 - CTIMEOUT flag clear bit"]
-            #[inline]
-            pub fn ctimeoutc(&self) -> CTIMEOUTCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTIMEOUTCR { bits }
-            }
-            #[doc = "Bit 1 - DCRCFAIL flag clear bit"]
-            #[inline]
-            pub fn dcrcfailc(&self) -> DCRCFAILCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCRCFAILCR { bits }
-            }
-            #[doc = "Bit 0 - CCRCFAIL flag clear bit"]
-            #[inline]
-            pub fn ccrcfailc(&self) -> CCRCFAILCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCRCFAILCR { bits }
-            }
-        }
-        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 23 - CEATAEND flag clear bit"]
-            #[inline]
-            pub fn ceataendc(&mut self) -> _CEATAENDCW {
-                _CEATAENDCW { w: self }
-            }
-            #[doc = "Bit 22 - SDIOIT flag clear bit"]
-            #[inline]
-            pub fn sdioitc(&mut self) -> _SDIOITCW {
-                _SDIOITCW { w: self }
-            }
-            #[doc = "Bit 10 - DBCKEND flag clear bit"]
-            #[inline]
-            pub fn dbckendc(&mut self) -> _DBCKENDCW {
-                _DBCKENDCW { w: self }
-            }
-            #[doc = "Bit 9 - STBITERR flag clear bit"]
-            #[inline]
-            pub fn stbiterrc(&mut self) -> _STBITERRCW {
-                _STBITERRCW { w: self }
-            }
-            #[doc = "Bit 8 - DATAEND flag clear bit"]
-            #[inline]
-            pub fn dataendc(&mut self) -> _DATAENDCW {
-                _DATAENDCW { w: self }
-            }
-            #[doc = "Bit 7 - CMDSENT flag clear bit"]
-            #[inline]
-            pub fn cmdsentc(&mut self) -> _CMDSENTCW {
-                _CMDSENTCW { w: self }
-            }
-            #[doc = "Bit 6 - CMDREND flag clear bit"]
-            #[inline]
-            pub fn cmdrendc(&mut self) -> _CMDRENDCW {
-                _CMDRENDCW { w: self }
-            }
-            #[doc = "Bit 5 - RXOVERR flag clear bit"]
-            #[inline]
-            pub fn rxoverrc(&mut self) -> _RXOVERRCW {
-                _RXOVERRCW { w: self }
-            }
-            #[doc = "Bit 4 - TXUNDERR flag clear bit"]
-            #[inline]
-            pub fn txunderrc(&mut self) -> _TXUNDERRCW {
-                _TXUNDERRCW { w: self }
-            }
-            #[doc = "Bit 3 - DTIMEOUT flag clear bit"]
-            #[inline]
-            pub fn dtimeoutc(&mut self) -> _DTIMEOUTCW {
-                _DTIMEOUTCW { w: self }
-            }
-            #[doc = "Bit 2 - CTIMEOUT flag clear bit"]
-            #[inline]
-            pub fn ctimeoutc(&mut self) -> _CTIMEOUTCW {
-                _CTIMEOUTCW { w: self }
-            }
-            #[doc = "Bit 1 - DCRCFAIL flag clear bit"]
-            #[inline]
-            pub fn dcrcfailc(&mut self) -> _DCRCFAILCW {
-                _DCRCFAILCW { w: self }
-            }
-            #[doc = "Bit 0 - CCRCFAIL flag clear bit"]
-            #[inline]
-            pub fn ccrcfailc(&mut self) -> _CCRCFAILCW {
-                _CCRCFAILCW { w: self }
-            }
-        }
-    }
-    #[doc = "mask register"]
-    pub struct MASK {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mask register"]
-    pub mod mask {
-        #[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::MASK {
-            #[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 = r" Value of the field"]
-        pub struct CEATAENDIER {
-            bits: bool,
-        }
-        impl CEATAENDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDIOITIER {
-            bits: bool,
-        }
-        impl SDIOITIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXDAVLIER {
-            bits: bool,
-        }
-        impl RXDAVLIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXDAVLIER {
-            bits: bool,
-        }
-        impl TXDAVLIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFIFOEIER {
-            bits: bool,
-        }
-        impl RXFIFOEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFIFOEIER {
-            bits: bool,
-        }
-        impl TXFIFOEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFIFOFIER {
-            bits: bool,
-        }
-        impl RXFIFOFIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFIFOFIER {
-            bits: bool,
-        }
-        impl TXFIFOFIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFIFOHFIER {
-            bits: bool,
-        }
-        impl RXFIFOHFIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFIFOHEIER {
-            bits: bool,
-        }
-        impl TXFIFOHEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXACTIER {
-            bits: bool,
-        }
-        impl RXACTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXACTIER {
-            bits: bool,
-        }
-        impl TXACTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMDACTIER {
-            bits: bool,
-        }
-        impl CMDACTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBCKENDIER {
-            bits: bool,
-        }
-        impl DBCKENDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STBITERRIER {
-            bits: bool,
-        }
-        impl STBITERRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DATAENDIER {
-            bits: bool,
-        }
-        impl DATAENDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMDSENTIER {
-            bits: bool,
-        }
-        impl CMDSENTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMDRENDIER {
-            bits: bool,
-        }
-        impl CMDRENDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXOVERRIER {
-            bits: bool,
-        }
-        impl RXOVERRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXUNDERRIER {
-            bits: bool,
-        }
-        impl TXUNDERRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTIMEOUTIER {
-            bits: bool,
-        }
-        impl DTIMEOUTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTIMEOUTIER {
-            bits: bool,
-        }
-        impl CTIMEOUTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DCRCFAILIER {
-            bits: bool,
-        }
-        impl DCRCFAILIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCRCFAILIER {
-            bits: bool,
-        }
-        impl CCRCFAILIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CEATAENDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CEATAENDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDIOITIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDIOITIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXDAVLIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXDAVLIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXDAVLIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXDAVLIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXFIFOEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXFIFOEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFIFOEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFIFOEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXFIFOFIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXFIFOFIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFIFOFIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFIFOFIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXFIFOHFIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXFIFOHFIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFIFOHEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFIFOHEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXACTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXACTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXACTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXACTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMDACTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMDACTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBCKENDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBCKENDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STBITERRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STBITERRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DATAENDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATAENDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMDSENTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMDSENTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMDRENDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMDRENDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXOVERRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXOVERRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXUNDERRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXUNDERRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTIMEOUTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTIMEOUTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTIMEOUTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTIMEOUTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DCRCFAILIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCRCFAILIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CCRCFAILIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCRCFAILIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 23 - CE-ATA command completion signal received interrupt enable"]
-            #[inline]
-            pub fn ceataendie(&self) -> CEATAENDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CEATAENDIER { bits }
-            }
-            #[doc = "Bit 22 - SDIO mode interrupt received interrupt enable"]
-            #[inline]
-            pub fn sdioitie(&self) -> SDIOITIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDIOITIER { bits }
-            }
-            #[doc = "Bit 21 - Data available in Rx FIFO interrupt enable"]
-            #[inline]
-            pub fn rxdavlie(&self) -> RXDAVLIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXDAVLIER { bits }
-            }
-            #[doc = "Bit 20 - Data available in Tx FIFO interrupt enable"]
-            #[inline]
-            pub fn txdavlie(&self) -> TXDAVLIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXDAVLIER { bits }
-            }
-            #[doc = "Bit 19 - Rx FIFO empty interrupt enable"]
-            #[inline]
-            pub fn rxfifoeie(&self) -> RXFIFOEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFIFOEIER { bits }
-            }
-            #[doc = "Bit 18 - Tx FIFO empty interrupt enable"]
-            #[inline]
-            pub fn txfifoeie(&self) -> TXFIFOEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFIFOEIER { bits }
-            }
-            #[doc = "Bit 17 - Rx FIFO full interrupt enable"]
-            #[inline]
-            pub fn rxfifofie(&self) -> RXFIFOFIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFIFOFIER { bits }
-            }
-            #[doc = "Bit 16 - Tx FIFO full interrupt enable"]
-            #[inline]
-            pub fn txfifofie(&self) -> TXFIFOFIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFIFOFIER { bits }
-            }
-            #[doc = "Bit 15 - Rx FIFO half full interrupt enable"]
-            #[inline]
-            pub fn rxfifohfie(&self) -> RXFIFOHFIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFIFOHFIER { bits }
-            }
-            #[doc = "Bit 14 - Tx FIFO half empty interrupt enable"]
-            #[inline]
-            pub fn txfifoheie(&self) -> TXFIFOHEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFIFOHEIER { bits }
-            }
-            #[doc = "Bit 13 - Data receive acting interrupt enable"]
-            #[inline]
-            pub fn rxactie(&self) -> RXACTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXACTIER { bits }
-            }
-            #[doc = "Bit 12 - Data transmit acting interrupt enable"]
-            #[inline]
-            pub fn txactie(&self) -> TXACTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXACTIER { bits }
-            }
-            #[doc = "Bit 11 - Command acting interrupt enable"]
-            #[inline]
-            pub fn cmdactie(&self) -> CMDACTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMDACTIER { bits }
-            }
-            #[doc = "Bit 10 - Data block end interrupt enable"]
-            #[inline]
-            pub fn dbckendie(&self) -> DBCKENDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBCKENDIER { bits }
-            }
-            #[doc = "Bit 9 - Start bit error interrupt enable"]
-            #[inline]
-            pub fn stbiterrie(&self) -> STBITERRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STBITERRIER { bits }
-            }
-            #[doc = "Bit 8 - Data end interrupt enable"]
-            #[inline]
-            pub fn dataendie(&self) -> DATAENDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DATAENDIER { bits }
-            }
-            #[doc = "Bit 7 - Command sent interrupt enable"]
-            #[inline]
-            pub fn cmdsentie(&self) -> CMDSENTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMDSENTIER { bits }
-            }
-            #[doc = "Bit 6 - Command response received interrupt enable"]
-            #[inline]
-            pub fn cmdrendie(&self) -> CMDRENDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMDRENDIER { bits }
-            }
-            #[doc = "Bit 5 - Rx FIFO overrun error interrupt enable"]
-            #[inline]
-            pub fn rxoverrie(&self) -> RXOVERRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXOVERRIER { bits }
-            }
-            #[doc = "Bit 4 - Tx FIFO underrun error interrupt enable"]
-            #[inline]
-            pub fn txunderrie(&self) -> TXUNDERRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXUNDERRIER { bits }
-            }
-            #[doc = "Bit 3 - Data timeout interrupt enable"]
-            #[inline]
-            pub fn dtimeoutie(&self) -> DTIMEOUTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTIMEOUTIER { bits }
-            }
-            #[doc = "Bit 2 - Command timeout interrupt enable"]
-            #[inline]
-            pub fn ctimeoutie(&self) -> CTIMEOUTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTIMEOUTIER { bits }
-            }
-            #[doc = "Bit 1 - Data CRC fail interrupt enable"]
-            #[inline]
-            pub fn dcrcfailie(&self) -> DCRCFAILIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCRCFAILIER { bits }
-            }
-            #[doc = "Bit 0 - Command CRC fail interrupt enable"]
-            #[inline]
-            pub fn ccrcfailie(&self) -> CCRCFAILIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCRCFAILIER { bits }
-            }
-        }
-        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 23 - CE-ATA command completion signal received interrupt enable"]
-            #[inline]
-            pub fn ceataendie(&mut self) -> _CEATAENDIEW {
-                _CEATAENDIEW { w: self }
-            }
-            #[doc = "Bit 22 - SDIO mode interrupt received interrupt enable"]
-            #[inline]
-            pub fn sdioitie(&mut self) -> _SDIOITIEW {
-                _SDIOITIEW { w: self }
-            }
-            #[doc = "Bit 21 - Data available in Rx FIFO interrupt enable"]
-            #[inline]
-            pub fn rxdavlie(&mut self) -> _RXDAVLIEW {
-                _RXDAVLIEW { w: self }
-            }
-            #[doc = "Bit 20 - Data available in Tx FIFO interrupt enable"]
-            #[inline]
-            pub fn txdavlie(&mut self) -> _TXDAVLIEW {
-                _TXDAVLIEW { w: self }
-            }
-            #[doc = "Bit 19 - Rx FIFO empty interrupt enable"]
-            #[inline]
-            pub fn rxfifoeie(&mut self) -> _RXFIFOEIEW {
-                _RXFIFOEIEW { w: self }
-            }
-            #[doc = "Bit 18 - Tx FIFO empty interrupt enable"]
-            #[inline]
-            pub fn txfifoeie(&mut self) -> _TXFIFOEIEW {
-                _TXFIFOEIEW { w: self }
-            }
-            #[doc = "Bit 17 - Rx FIFO full interrupt enable"]
-            #[inline]
-            pub fn rxfifofie(&mut self) -> _RXFIFOFIEW {
-                _RXFIFOFIEW { w: self }
-            }
-            #[doc = "Bit 16 - Tx FIFO full interrupt enable"]
-            #[inline]
-            pub fn txfifofie(&mut self) -> _TXFIFOFIEW {
-                _TXFIFOFIEW { w: self }
-            }
-            #[doc = "Bit 15 - Rx FIFO half full interrupt enable"]
-            #[inline]
-            pub fn rxfifohfie(&mut self) -> _RXFIFOHFIEW {
-                _RXFIFOHFIEW { w: self }
-            }
-            #[doc = "Bit 14 - Tx FIFO half empty interrupt enable"]
-            #[inline]
-            pub fn txfifoheie(&mut self) -> _TXFIFOHEIEW {
-                _TXFIFOHEIEW { w: self }
-            }
-            #[doc = "Bit 13 - Data receive acting interrupt enable"]
-            #[inline]
-            pub fn rxactie(&mut self) -> _RXACTIEW {
-                _RXACTIEW { w: self }
-            }
-            #[doc = "Bit 12 - Data transmit acting interrupt enable"]
-            #[inline]
-            pub fn txactie(&mut self) -> _TXACTIEW {
-                _TXACTIEW { w: self }
-            }
-            #[doc = "Bit 11 - Command acting interrupt enable"]
-            #[inline]
-            pub fn cmdactie(&mut self) -> _CMDACTIEW {
-                _CMDACTIEW { w: self }
-            }
-            #[doc = "Bit 10 - Data block end interrupt enable"]
-            #[inline]
-            pub fn dbckendie(&mut self) -> _DBCKENDIEW {
-                _DBCKENDIEW { w: self }
-            }
-            #[doc = "Bit 9 - Start bit error interrupt enable"]
-            #[inline]
-            pub fn stbiterrie(&mut self) -> _STBITERRIEW {
-                _STBITERRIEW { w: self }
-            }
-            #[doc = "Bit 8 - Data end interrupt enable"]
-            #[inline]
-            pub fn dataendie(&mut self) -> _DATAENDIEW {
-                _DATAENDIEW { w: self }
-            }
-            #[doc = "Bit 7 - Command sent interrupt enable"]
-            #[inline]
-            pub fn cmdsentie(&mut self) -> _CMDSENTIEW {
-                _CMDSENTIEW { w: self }
-            }
-            #[doc = "Bit 6 - Command response received interrupt enable"]
-            #[inline]
-            pub fn cmdrendie(&mut self) -> _CMDRENDIEW {
-                _CMDRENDIEW { w: self }
-            }
-            #[doc = "Bit 5 - Rx FIFO overrun error interrupt enable"]
-            #[inline]
-            pub fn rxoverrie(&mut self) -> _RXOVERRIEW {
-                _RXOVERRIEW { w: self }
-            }
-            #[doc = "Bit 4 - Tx FIFO underrun error interrupt enable"]
-            #[inline]
-            pub fn txunderrie(&mut self) -> _TXUNDERRIEW {
-                _TXUNDERRIEW { w: self }
-            }
-            #[doc = "Bit 3 - Data timeout interrupt enable"]
-            #[inline]
-            pub fn dtimeoutie(&mut self) -> _DTIMEOUTIEW {
-                _DTIMEOUTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Command timeout interrupt enable"]
-            #[inline]
-            pub fn ctimeoutie(&mut self) -> _CTIMEOUTIEW {
-                _CTIMEOUTIEW { w: self }
-            }
-            #[doc = "Bit 1 - Data CRC fail interrupt enable"]
-            #[inline]
-            pub fn dcrcfailie(&mut self) -> _DCRCFAILIEW {
-                _DCRCFAILIEW { w: self }
-            }
-            #[doc = "Bit 0 - Command CRC fail interrupt enable"]
-            #[inline]
-            pub fn ccrcfailie(&mut self) -> _CCRCFAILIEW {
-                _CCRCFAILIEW { w: self }
-            }
-        }
-    }
-    #[doc = "FIFO counter register"]
-    pub struct FIFOCNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "FIFO counter register"]
-    pub mod fifocnt {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FIFOCNT {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FIFOCOUNTR {
-            bits: u32,
-        }
-        impl FIFOCOUNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:23 - Remaining number of words to be written to or read from the FIFO."]
-            #[inline]
-            pub fn fifocount(&self) -> FIFOCOUNTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                FIFOCOUNTR { bits }
-            }
-        }
-    }
-    #[doc = "data FIFO register"]
-    pub struct FIFO {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data FIFO register"]
-    pub mod fifo {
-        #[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::FIFO {
-            #[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 = r" Value of the field"]
-        pub struct FIFODATAR {
-            bits: u32,
-        }
-        impl FIFODATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FIFODATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FIFODATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Receive and transmit FIFO data"]
-            #[inline]
-            pub fn fifodata(&self) -> FIFODATAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                FIFODATAR { bits }
-            }
-        }
-        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 0:31 - Receive and transmit FIFO data"]
-            #[inline]
-            pub fn fifodata(&mut self) -> _FIFODATAW {
-                _FIFODATAW { w: self }
-            }
-        }
-    }
-}
-#[doc = "System configuration controller"]
-pub struct SYSCFG {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for SYSCFG {}
-impl SYSCFG {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const syscfg::RegisterBlock {
-        0x4001_3800 as *const _
-    }
-}
-impl Deref for SYSCFG {
-    type Target = syscfg::RegisterBlock;
-    fn deref(&self) -> &syscfg::RegisterBlock {
-        unsafe { &*SYSCFG::ptr() }
-    }
-}
-#[doc = "System configuration controller"]
-pub mod syscfg {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - memory remap register"]
-        pub memrm: MEMRM,
-        #[doc = "0x04 - peripheral mode configuration register"]
-        pub pmc: PMC,
-        #[doc = "0x08 - external interrupt configuration register 1"]
-        pub exticr1: EXTICR1,
-        #[doc = "0x0c - external interrupt configuration register 2"]
-        pub exticr2: EXTICR2,
-        #[doc = "0x10 - external interrupt configuration register 3"]
-        pub exticr3: EXTICR3,
-        #[doc = "0x14 - external interrupt configuration register 4"]
-        pub exticr4: EXTICR4,
-        _reserved0: [u8; 8usize],
-        #[doc = "0x20 - Compensation cell control register"]
-        pub cmpcr: CMPCR,
-        _reserved1: [u8; 8usize],
-        #[doc = "0x2c - I2C_BUFOUT"]
-        pub i2c_bufout: I2C_BUFOUT,
-    }
-    #[doc = "memory remap register"]
-    pub struct MEMRM {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "memory remap register"]
-    pub mod memrm {
-        #[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::MEMRM {
-            #[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 = r" Value of the field"]
-        pub struct MEM_MODER {
-            bits: u8,
-        }
-        impl MEM_MODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEM_MODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEM_MODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 0:1 - MEM_MODE"]
-            #[inline]
-            pub fn mem_mode(&self) -> MEM_MODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEM_MODER { bits }
-            }
-        }
-        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 0:1 - MEM_MODE"]
-            #[inline]
-            pub fn mem_mode(&mut self) -> _MEM_MODEW {
-                _MEM_MODEW { w: self }
-            }
-        }
-    }
-    #[doc = "peripheral mode configuration register"]
-    pub struct PMC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "peripheral mode configuration register"]
-    pub mod pmc {
-        #[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::PMC {
-            #[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 = r" Value of the field"]
-        pub struct ADC1DC2R {
-            bits: bool,
-        }
-        impl ADC1DC2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ADC1DC2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADC1DC2W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 16 - ADC1DC2"]
-            #[inline]
-            pub fn adc1dc2(&self) -> ADC1DC2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADC1DC2R { bits }
-            }
-        }
-        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 16 - ADC1DC2"]
-            #[inline]
-            pub fn adc1dc2(&mut self) -> _ADC1DC2W {
-                _ADC1DC2W { w: self }
-            }
-        }
-    }
-    #[doc = "external interrupt configuration register 1"]
-    pub struct EXTICR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "external interrupt configuration register 1"]
-    pub mod exticr1 {
-        #[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 = r" Value of the field"]
-        pub struct EXTI3R {
-            bits: u8,
-        }
-        impl EXTI3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI2R {
-            bits: u8,
-        }
-        impl EXTI2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI1R {
-            bits: u8,
-        }
-        impl EXTI1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI0R {
-            bits: u8,
-        }
-        impl EXTI0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 x configuration (x = 0 to 3)"]
-            #[inline]
-            pub fn exti3(&self) -> EXTI3R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI3R { bits }
-            }
-            #[doc = "Bits 8:11 - EXTI x configuration (x = 0 to 3)"]
-            #[inline]
-            pub fn exti2(&self) -> EXTI2R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI2R { bits }
-            }
-            #[doc = "Bits 4:7 - EXTI x configuration (x = 0 to 3)"]
-            #[inline]
-            pub fn exti1(&self) -> EXTI1R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI1R { bits }
-            }
-            #[doc = "Bits 0:3 - EXTI x configuration (x = 0 to 3)"]
-            #[inline]
-            pub fn exti0(&self) -> EXTI0R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI0R { bits }
-            }
-        }
-        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 x configuration (x = 0 to 3)"]
-            #[inline]
-            pub fn exti3(&mut self) -> _EXTI3W {
-                _EXTI3W { w: self }
-            }
-            #[doc = "Bits 8:11 - EXTI x configuration (x = 0 to 3)"]
-            #[inline]
-            pub fn exti2(&mut self) -> _EXTI2W {
-                _EXTI2W { w: self }
-            }
-            #[doc = "Bits 4:7 - EXTI x configuration (x = 0 to 3)"]
-            #[inline]
-            pub fn exti1(&mut self) -> _EXTI1W {
-                _EXTI1W { w: self }
-            }
-            #[doc = "Bits 0:3 - EXTI x configuration (x = 0 to 3)"]
-            #[inline]
-            pub fn exti0(&mut self) -> _EXTI0W {
-                _EXTI0W { w: self }
-            }
-        }
-    }
-    #[doc = "external interrupt configuration register 2"]
-    pub struct EXTICR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "external interrupt configuration register 2"]
-    pub mod exticr2 {
-        #[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 = r" Value of the field"]
-        pub struct EXTI7R {
-            bits: u8,
-        }
-        impl EXTI7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI6R {
-            bits: u8,
-        }
-        impl EXTI6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI5R {
-            bits: u8,
-        }
-        impl EXTI5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI4R {
-            bits: u8,
-        }
-        impl EXTI4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 x configuration (x = 4 to 7)"]
-            #[inline]
-            pub fn exti7(&self) -> EXTI7R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI7R { bits }
-            }
-            #[doc = "Bits 8:11 - EXTI x configuration (x = 4 to 7)"]
-            #[inline]
-            pub fn exti6(&self) -> EXTI6R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI6R { bits }
-            }
-            #[doc = "Bits 4:7 - EXTI x configuration (x = 4 to 7)"]
-            #[inline]
-            pub fn exti5(&self) -> EXTI5R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI5R { bits }
-            }
-            #[doc = "Bits 0:3 - EXTI x configuration (x = 4 to 7)"]
-            #[inline]
-            pub fn exti4(&self) -> EXTI4R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI4R { bits }
-            }
-        }
-        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 x configuration (x = 4 to 7)"]
-            #[inline]
-            pub fn exti7(&mut self) -> _EXTI7W {
-                _EXTI7W { w: self }
-            }
-            #[doc = "Bits 8:11 - EXTI x configuration (x = 4 to 7)"]
-            #[inline]
-            pub fn exti6(&mut self) -> _EXTI6W {
-                _EXTI6W { w: self }
-            }
-            #[doc = "Bits 4:7 - EXTI x configuration (x = 4 to 7)"]
-            #[inline]
-            pub fn exti5(&mut self) -> _EXTI5W {
-                _EXTI5W { w: self }
-            }
-            #[doc = "Bits 0:3 - EXTI x configuration (x = 4 to 7)"]
-            #[inline]
-            pub fn exti4(&mut self) -> _EXTI4W {
-                _EXTI4W { w: self }
-            }
-        }
-    }
-    #[doc = "external interrupt configuration register 3"]
-    pub struct EXTICR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "external interrupt configuration register 3"]
-    pub mod exticr3 {
-        #[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::EXTICR3 {
-            #[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 = r" Value of the field"]
-        pub struct EXTI11R {
-            bits: u8,
-        }
-        impl EXTI11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI10R {
-            bits: u8,
-        }
-        impl EXTI10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI9R {
-            bits: u8,
-        }
-        impl EXTI9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI8R {
-            bits: u8,
-        }
-        impl EXTI8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 x configuration (x = 8 to 11)"]
-            #[inline]
-            pub fn exti11(&self) -> EXTI11R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI11R { bits }
-            }
-            #[doc = "Bits 8:11 - EXTI10"]
-            #[inline]
-            pub fn exti10(&self) -> EXTI10R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI10R { bits }
-            }
-            #[doc = "Bits 4:7 - EXTI x configuration (x = 8 to 11)"]
-            #[inline]
-            pub fn exti9(&self) -> EXTI9R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI9R { bits }
-            }
-            #[doc = "Bits 0:3 - EXTI x configuration (x = 8 to 11)"]
-            #[inline]
-            pub fn exti8(&self) -> EXTI8R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI8R { bits }
-            }
-        }
-        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 x configuration (x = 8 to 11)"]
-            #[inline]
-            pub fn exti11(&mut self) -> _EXTI11W {
-                _EXTI11W { w: self }
-            }
-            #[doc = "Bits 8:11 - EXTI10"]
-            #[inline]
-            pub fn exti10(&mut self) -> _EXTI10W {
-                _EXTI10W { w: self }
-            }
-            #[doc = "Bits 4:7 - EXTI x configuration (x = 8 to 11)"]
-            #[inline]
-            pub fn exti9(&mut self) -> _EXTI9W {
-                _EXTI9W { w: self }
-            }
-            #[doc = "Bits 0:3 - EXTI x configuration (x = 8 to 11)"]
-            #[inline]
-            pub fn exti8(&mut self) -> _EXTI8W {
-                _EXTI8W { w: self }
-            }
-        }
-    }
-    #[doc = "external interrupt configuration register 4"]
-    pub struct EXTICR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "external interrupt configuration register 4"]
-    pub mod exticr4 {
-        #[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::EXTICR4 {
-            #[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 = r" Value of the field"]
-        pub struct EXTI15R {
-            bits: u8,
-        }
-        impl EXTI15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI14R {
-            bits: u8,
-        }
-        impl EXTI14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI13R {
-            bits: u8,
-        }
-        impl EXTI13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXTI12R {
-            bits: u8,
-        }
-        impl EXTI12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXTI12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTI12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 x configuration (x = 12 to 15)"]
-            #[inline]
-            pub fn exti15(&self) -> EXTI15R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI15R { bits }
-            }
-            #[doc = "Bits 8:11 - EXTI x configuration (x = 12 to 15)"]
-            #[inline]
-            pub fn exti14(&self) -> EXTI14R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI14R { bits }
-            }
-            #[doc = "Bits 4:7 - EXTI x configuration (x = 12 to 15)"]
-            #[inline]
-            pub fn exti13(&self) -> EXTI13R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI13R { bits }
-            }
-            #[doc = "Bits 0:3 - EXTI x configuration (x = 12 to 15)"]
-            #[inline]
-            pub fn exti12(&self) -> EXTI12R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXTI12R { bits }
-            }
-        }
-        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 x configuration (x = 12 to 15)"]
-            #[inline]
-            pub fn exti15(&mut self) -> _EXTI15W {
-                _EXTI15W { w: self }
-            }
-            #[doc = "Bits 8:11 - EXTI x configuration (x = 12 to 15)"]
-            #[inline]
-            pub fn exti14(&mut self) -> _EXTI14W {
-                _EXTI14W { w: self }
-            }
-            #[doc = "Bits 4:7 - EXTI x configuration (x = 12 to 15)"]
-            #[inline]
-            pub fn exti13(&mut self) -> _EXTI13W {
-                _EXTI13W { w: self }
-            }
-            #[doc = "Bits 0:3 - EXTI x configuration (x = 12 to 15)"]
-            #[inline]
-            pub fn exti12(&mut self) -> _EXTI12W {
-                _EXTI12W { w: self }
-            }
-        }
-    }
-    #[doc = "Compensation cell control register"]
-    pub struct CMPCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Compensation cell control register"]
-    pub mod cmpcr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::CMPCR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct READYR {
-            bits: bool,
-        }
-        impl READYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMP_PDR {
-            bits: bool,
-        }
-        impl CMP_PDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 8 - READY"]
-            #[inline]
-            pub fn ready(&self) -> READYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                READYR { bits }
-            }
-            #[doc = "Bit 0 - Compensation cell power-down"]
-            #[inline]
-            pub fn cmp_pd(&self) -> CMP_PDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMP_PDR { bits }
-            }
-        }
-    }
-    #[doc = "I2C_BUFOUT"]
-    pub struct I2C_BUFOUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "I2C_BUFOUT"]
-    pub mod i2c_bufout {
-        #[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::I2C_BUFOUT {
-            #[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 = r" Value of the field"]
-        pub struct I2C4SCLR {
-            bits: bool,
-        }
-        impl I2C4SCLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2C4SDAR {
-            bits: bool,
-        }
-        impl I2C4SDAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _I2C4SCLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C4SCLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2C4SDAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2C4SDAW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - I2C4SCL"]
-            #[inline]
-            pub fn i2c4scl(&self) -> I2C4SCLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C4SCLR { bits }
-            }
-            #[doc = "Bit 1 - I2C4SDA"]
-            #[inline]
-            pub fn i2c4sda(&self) -> I2C4SDAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2C4SDAR { bits }
-            }
-        }
-        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 - I2C4SCL"]
-            #[inline]
-            pub fn i2c4scl(&mut self) -> _I2C4SCLW {
-                _I2C4SCLW { w: self }
-            }
-            #[doc = "Bit 1 - I2C4SDA"]
-            #[inline]
-            pub fn i2c4sda(&mut self) -> _I2C4SDAW {
-                _I2C4SDAW { w: self }
-            }
-        }
-    }
-}
-#[doc = "Advanced-timers"]
-pub struct TIM1 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM1 {}
-impl TIM1 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim1::RegisterBlock {
-        0x4001_0000 as *const _
-    }
-}
-impl Deref for TIM1 {
-    type Target = tim1::RegisterBlock;
-    fn deref(&self) -> &tim1::RegisterBlock {
-        unsafe { &*TIM1::ptr() }
-    }
-}
-#[doc = "Advanced-timers"]
-pub mod tim1 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x08 - slave mode control register"]
-        pub smcr: SMCR,
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register 1 (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        #[doc = "0x1c - capture/compare mode register 2 (output mode)"]
-        pub ccmr2_output: CCMR2_OUTPUT,
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        #[doc = "0x30 - repetition counter register"]
-        pub rcr: RCR,
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-        #[doc = "0x38 - capture/compare register 2"]
-        pub ccr2: CCR2,
-        #[doc = "0x3c - capture/compare register 3"]
-        pub ccr3: CCR3,
-        #[doc = "0x40 - capture/compare register 4"]
-        pub ccr4: CCR4,
-        #[doc = "0x44 - break and dead-time register"]
-        pub bdtr: BDTR,
-        #[doc = "0x48 - DMA control register"]
-        pub dcr: DCR,
-        #[doc = "0x4c - DMA address for full transfer"]
-        pub dmar: DMAR,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMSR {
-            bits: u8,
-        }
-        impl CMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DIRR {
-            bits: bool,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPMR {
-            bits: bool,
-        }
-        impl OPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bits 5:6 - Center-aligned mode selection"]
-            #[inline]
-            pub fn cms(&self) -> CMSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CMSR { bits }
-            }
-            #[doc = "Bit 4 - Direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&self) -> OPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPMR { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bits 5:6 - Center-aligned mode selection"]
-            #[inline]
-            pub fn cms(&mut self) -> _CMSW {
-                _CMSW { w: self }
-            }
-            #[doc = "Bit 4 - Direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&mut self) -> _OPMW {
-                _OPMW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct OIS4R {
-            bits: bool,
-        }
-        impl OIS4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OIS3NR {
-            bits: bool,
-        }
-        impl OIS3NR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OIS3R {
-            bits: bool,
-        }
-        impl OIS3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OIS2NR {
-            bits: bool,
-        }
-        impl OIS2NR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OIS2R {
-            bits: bool,
-        }
-        impl OIS2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OIS1NR {
-            bits: bool,
-        }
-        impl OIS1NR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OIS1R {
-            bits: bool,
-        }
-        impl OIS1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TI1SR {
-            bits: bool,
-        }
-        impl TI1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MMSR {
-            bits: u8,
-        }
-        impl MMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCDSR {
-            bits: bool,
-        }
-        impl CCDSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCUSR {
-            bits: bool,
-        }
-        impl CCUSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCPCR {
-            bits: bool,
-        }
-        impl CCPCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OIS4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OIS4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OIS3NW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OIS3NW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OIS3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OIS3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OIS2NW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OIS2NW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OIS2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OIS2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OIS1NW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OIS1NW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OIS1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OIS1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TI1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TI1SW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCDSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCDSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CCUSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCUSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CCPCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCPCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 14 - Output Idle state 4"]
-            #[inline]
-            pub fn ois4(&self) -> OIS4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OIS4R { bits }
-            }
-            #[doc = "Bit 13 - Output Idle state 3"]
-            #[inline]
-            pub fn ois3n(&self) -> OIS3NR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OIS3NR { bits }
-            }
-            #[doc = "Bit 12 - Output Idle state 3"]
-            #[inline]
-            pub fn ois3(&self) -> OIS3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OIS3R { bits }
-            }
-            #[doc = "Bit 11 - Output Idle state 2"]
-            #[inline]
-            pub fn ois2n(&self) -> OIS2NR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OIS2NR { bits }
-            }
-            #[doc = "Bit 10 - Output Idle state 2"]
-            #[inline]
-            pub fn ois2(&self) -> OIS2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OIS2R { bits }
-            }
-            #[doc = "Bit 9 - Output Idle state 1"]
-            #[inline]
-            pub fn ois1n(&self) -> OIS1NR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OIS1NR { bits }
-            }
-            #[doc = "Bit 8 - Output Idle state 1"]
-            #[inline]
-            pub fn ois1(&self) -> OIS1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OIS1R { bits }
-            }
-            #[doc = "Bit 7 - TI1 selection"]
-            #[inline]
-            pub fn ti1s(&self) -> TI1SR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TI1SR { bits }
-            }
-            #[doc = "Bits 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&self) -> MMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MMSR { bits }
-            }
-            #[doc = "Bit 3 - Capture/compare DMA selection"]
-            #[inline]
-            pub fn ccds(&self) -> CCDSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCDSR { bits }
-            }
-            #[doc = "Bit 2 - Capture/compare control update selection"]
-            #[inline]
-            pub fn ccus(&self) -> CCUSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCUSR { bits }
-            }
-            #[doc = "Bit 0 - Capture/compare preloaded control"]
-            #[inline]
-            pub fn ccpc(&self) -> CCPCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCPCR { bits }
-            }
-        }
-        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 14 - Output Idle state 4"]
-            #[inline]
-            pub fn ois4(&mut self) -> _OIS4W {
-                _OIS4W { w: self }
-            }
-            #[doc = "Bit 13 - Output Idle state 3"]
-            #[inline]
-            pub fn ois3n(&mut self) -> _OIS3NW {
-                _OIS3NW { w: self }
-            }
-            #[doc = "Bit 12 - Output Idle state 3"]
-            #[inline]
-            pub fn ois3(&mut self) -> _OIS3W {
-                _OIS3W { w: self }
-            }
-            #[doc = "Bit 11 - Output Idle state 2"]
-            #[inline]
-            pub fn ois2n(&mut self) -> _OIS2NW {
-                _OIS2NW { w: self }
-            }
-            #[doc = "Bit 10 - Output Idle state 2"]
-            #[inline]
-            pub fn ois2(&mut self) -> _OIS2W {
-                _OIS2W { w: self }
-            }
-            #[doc = "Bit 9 - Output Idle state 1"]
-            #[inline]
-            pub fn ois1n(&mut self) -> _OIS1NW {
-                _OIS1NW { w: self }
-            }
-            #[doc = "Bit 8 - Output Idle state 1"]
-            #[inline]
-            pub fn ois1(&mut self) -> _OIS1W {
-                _OIS1W { w: self }
-            }
-            #[doc = "Bit 7 - TI1 selection"]
-            #[inline]
-            pub fn ti1s(&mut self) -> _TI1SW {
-                _TI1SW { w: self }
-            }
-            #[doc = "Bits 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&mut self) -> _MMSW {
-                _MMSW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/compare DMA selection"]
-            #[inline]
-            pub fn ccds(&mut self) -> _CCDSW {
-                _CCDSW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/compare control update selection"]
-            #[inline]
-            pub fn ccus(&mut self) -> _CCUSW {
-                _CCUSW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/compare preloaded control"]
-            #[inline]
-            pub fn ccpc(&mut self) -> _CCPCW {
-                _CCPCW { w: self }
-            }
-        }
-    }
-    #[doc = "slave mode control register"]
-    pub struct SMCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "slave mode control register"]
-    pub mod smcr {
-        #[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::SMCR {
-            #[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 = r" Value of the field"]
-        pub struct ETPR {
-            bits: bool,
-        }
-        impl ETPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ECER {
-            bits: bool,
-        }
-        impl ECER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ETPSR {
-            bits: u8,
-        }
-        impl ETPSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ETFR {
-            bits: u8,
-        }
-        impl ETFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSMR {
-            bits: bool,
-        }
-        impl MSMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSR {
-            bits: u8,
-        }
-        impl TSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SMSR {
-            bits: u8,
-        }
-        impl SMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ETPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ECEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ETPSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETPSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ETFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 = "Bit 15 - External trigger polarity"]
-            #[inline]
-            pub fn etp(&self) -> ETPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ETPR { bits }
-            }
-            #[doc = "Bit 14 - External clock enable"]
-            #[inline]
-            pub fn ece(&self) -> ECER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ECER { bits }
-            }
-            #[doc = "Bits 12:13 - External trigger prescaler"]
-            #[inline]
-            pub fn etps(&self) -> ETPSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ETPSR { bits }
-            }
-            #[doc = "Bits 8:11 - External trigger filter"]
-            #[inline]
-            pub fn etf(&self) -> ETFR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ETFR { bits }
-            }
-            #[doc = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&self) -> MSMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSMR { bits }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&self) -> TSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TSR { bits }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&self) -> SMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SMSR { bits }
-            }
-        }
-        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 15 - External trigger polarity"]
-            #[inline]
-            pub fn etp(&mut self) -> _ETPW {
-                _ETPW { w: self }
-            }
-            #[doc = "Bit 14 - External clock enable"]
-            #[inline]
-            pub fn ece(&mut self) -> _ECEW {
-                _ECEW { w: self }
-            }
-            #[doc = "Bits 12:13 - External trigger prescaler"]
-            #[inline]
-            pub fn etps(&mut self) -> _ETPSW {
-                _ETPSW { w: self }
-            }
-            #[doc = "Bits 8:11 - External trigger filter"]
-            #[inline]
-            pub fn etf(&mut self) -> _ETFW {
-                _ETFW { w: self }
-            }
-            #[doc = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&mut self) -> _MSMW {
-                _MSMW { w: self }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&mut self) -> _TSW {
-                _TSW { w: self }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&mut self) -> _SMSW {
-                _SMSW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct TDER {
-            bits: bool,
-        }
-        impl TDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct COMDER {
-            bits: bool,
-        }
-        impl COMDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4DER {
-            bits: bool,
-        }
-        impl CC4DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3DER {
-            bits: bool,
-        }
-        impl CC3DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2DER {
-            bits: bool,
-        }
-        impl CC2DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1DER {
-            bits: bool,
-        }
-        impl CC1DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDER {
-            bits: bool,
-        }
-        impl UDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BIER {
-            bits: bool,
-        }
-        impl BIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIER {
-            bits: bool,
-        }
-        impl TIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct COMIER {
-            bits: bool,
-        }
-        impl COMIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4IER {
-            bits: bool,
-        }
-        impl CC4IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3IER {
-            bits: bool,
-        }
-        impl CC3IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IER {
-            bits: bool,
-        }
-        impl CC2IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _COMDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COMDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _COMIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COMIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 14 - Trigger DMA request enable"]
-            #[inline]
-            pub fn tde(&self) -> TDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TDER { bits }
-            }
-            #[doc = "Bit 13 - COM DMA request enable"]
-            #[inline]
-            pub fn comde(&self) -> COMDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                COMDER { bits }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"]
-            #[inline]
-            pub fn cc4de(&self) -> CC4DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4DER { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"]
-            #[inline]
-            pub fn cc3de(&self) -> CC3DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3DER { bits }
-            }
-            #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"]
-            #[inline]
-            pub fn cc2de(&self) -> CC2DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2DER { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"]
-            #[inline]
-            pub fn cc1de(&self) -> CC1DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1DER { bits }
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&self) -> UDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDER { bits }
-            }
-            #[doc = "Bit 7 - Break interrupt enable"]
-            #[inline]
-            pub fn bie(&self) -> BIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BIER { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&self) -> TIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIER { bits }
-            }
-            #[doc = "Bit 5 - COM interrupt enable"]
-            #[inline]
-            pub fn comie(&self) -> COMIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                COMIER { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"]
-            #[inline]
-            pub fn cc4ie(&self) -> CC4IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4IER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"]
-            #[inline]
-            pub fn cc3ie(&self) -> CC3IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3IER { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&self) -> CC2IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IER { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 14 - Trigger DMA request enable"]
-            #[inline]
-            pub fn tde(&mut self) -> _TDEW {
-                _TDEW { w: self }
-            }
-            #[doc = "Bit 13 - COM DMA request enable"]
-            #[inline]
-            pub fn comde(&mut self) -> _COMDEW {
-                _COMDEW { w: self }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"]
-            #[inline]
-            pub fn cc4de(&mut self) -> _CC4DEW {
-                _CC4DEW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"]
-            #[inline]
-            pub fn cc3de(&mut self) -> _CC3DEW {
-                _CC3DEW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"]
-            #[inline]
-            pub fn cc2de(&mut self) -> _CC2DEW {
-                _CC2DEW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"]
-            #[inline]
-            pub fn cc1de(&mut self) -> _CC1DEW {
-                _CC1DEW { w: self }
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&mut self) -> _UDEW {
-                _UDEW { w: self }
-            }
-            #[doc = "Bit 7 - Break interrupt enable"]
-            #[inline]
-            pub fn bie(&mut self) -> _BIEW {
-                _BIEW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&mut self) -> _TIEW {
-                _TIEW { w: self }
-            }
-            #[doc = "Bit 5 - COM interrupt enable"]
-            #[inline]
-            pub fn comie(&mut self) -> _COMIEW {
-                _COMIEW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"]
-            #[inline]
-            pub fn cc4ie(&mut self) -> _CC4IEW {
-                _CC4IEW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"]
-            #[inline]
-            pub fn cc3ie(&mut self) -> _CC3IEW {
-                _CC3IEW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&mut self) -> _CC2IEW {
-                _CC2IEW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC4OFR {
-            bits: bool,
-        }
-        impl CC4OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3OFR {
-            bits: bool,
-        }
-        impl CC3OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2OFR {
-            bits: bool,
-        }
-        impl CC2OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BIFR {
-            bits: bool,
-        }
-        impl BIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIFR {
-            bits: bool,
-        }
-        impl TIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct COMIFR {
-            bits: bool,
-        }
-        impl COMIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4IFR {
-            bits: bool,
-        }
-        impl CC4IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3IFR {
-            bits: bool,
-        }
-        impl CC3IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IFR {
-            bits: bool,
-        }
-        impl CC2IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC4OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BIFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _COMIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COMIFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"]
-            #[inline]
-            pub fn cc4of(&self) -> CC4OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4OFR { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
-            #[inline]
-            pub fn cc3of(&self) -> CC3OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3OFR { bits }
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&self) -> CC2OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2OFR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 7 - Break interrupt flag"]
-            #[inline]
-            pub fn bif(&self) -> BIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BIFR { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&self) -> TIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIFR { bits }
-            }
-            #[doc = "Bit 5 - COM interrupt flag"]
-            #[inline]
-            pub fn comif(&self) -> COMIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                COMIFR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
-            #[inline]
-            pub fn cc4if(&self) -> CC4IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4IFR { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
-            #[inline]
-            pub fn cc3if(&self) -> CC3IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3IFR { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&self) -> CC2IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 12 - Capture/Compare 4 overcapture flag"]
-            #[inline]
-            pub fn cc4of(&mut self) -> _CC4OFW {
-                _CC4OFW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
-            #[inline]
-            pub fn cc3of(&mut self) -> _CC3OFW {
-                _CC3OFW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&mut self) -> _CC2OFW {
-                _CC2OFW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 7 - Break interrupt flag"]
-            #[inline]
-            pub fn bif(&mut self) -> _BIFW {
-                _BIFW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&mut self) -> _TIFW {
-                _TIFW { w: self }
-            }
-            #[doc = "Bit 5 - COM interrupt flag"]
-            #[inline]
-            pub fn comif(&mut self) -> _COMIFW {
-                _COMIFW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
-            #[inline]
-            pub fn cc4if(&mut self) -> _CC4IFW {
-                _CC4IFW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
-            #[inline]
-            pub fn cc3if(&mut self) -> _CC3IFW {
-                _CC3IFW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&mut self) -> _CC2IFW {
-                _CC2IFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _BGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _COMGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COMGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 7 - Break generation"]
-            #[inline]
-            pub fn bg(&mut self) -> _BGW {
-                _BGW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger generation"]
-            #[inline]
-            pub fn tg(&mut self) -> _TGW {
-                _TGW { w: self }
-            }
-            #[doc = "Bit 5 - Capture/Compare control update generation"]
-            #[inline]
-            pub fn comg(&mut self) -> _COMGW {
-                _COMGW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/compare 4 generation"]
-            #[inline]
-            pub fn cc4g(&mut self) -> _CC4GW {
-                _CC4GW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/compare 3 generation"]
-            #[inline]
-            pub fn cc3g(&mut self) -> _CC3GW {
-                _CC3GW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/compare 2 generation"]
-            #[inline]
-            pub fn cc2g(&mut self) -> _CC2GW {
-                _CC2GW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC2CER {
-            bits: bool,
-        }
-        impl OC2CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2MR {
-            bits: u8,
-        }
-        impl OC2MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC2PER {
-            bits: bool,
-        }
-        impl OC2PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2FER {
-            bits: bool,
-        }
-        impl OC2FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1CER {
-            bits: bool,
-        }
-        impl OC1CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 15 - Output Compare 2 clear enable"]
-            #[inline]
-            pub fn oc2ce(&self) -> OC2CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2CER { bits }
-            }
-            #[doc = "Bits 12:14 - Output Compare 2 mode"]
-            #[inline]
-            pub fn oc2m(&self) -> OC2MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC2MR { bits }
-            }
-            #[doc = "Bit 11 - Output Compare 2 preload enable"]
-            #[inline]
-            pub fn oc2pe(&self) -> OC2PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2PER { bits }
-            }
-            #[doc = "Bit 10 - Output Compare 2 fast enable"]
-            #[inline]
-            pub fn oc2fe(&self) -> OC2FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2FER { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bit 7 - Output Compare 1 clear enable"]
-            #[inline]
-            pub fn oc1ce(&self) -> OC1CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1CER { bits }
-            }
-            #[doc = "Bits 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 15 - Output Compare 2 clear enable"]
-            #[inline]
-            pub fn oc2ce(&mut self) -> _OC2CEW {
-                _OC2CEW { w: self }
-            }
-            #[doc = "Bits 12:14 - Output Compare 2 mode"]
-            #[inline]
-            pub fn oc2m(&mut self) -> _OC2MW {
-                _OC2MW { w: self }
-            }
-            #[doc = "Bit 11 - Output Compare 2 preload enable"]
-            #[inline]
-            pub fn oc2pe(&mut self) -> _OC2PEW {
-                _OC2PEW { w: self }
-            }
-            #[doc = "Bit 10 - Output Compare 2 fast enable"]
-            #[inline]
-            pub fn oc2fe(&mut self) -> _OC2FEW {
-                _OC2FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bit 7 - Output Compare 1 clear enable"]
-            #[inline]
-            pub fn oc1ce(&mut self) -> _OC1CEW {
-                _OC1CEW { w: self }
-            }
-            #[doc = "Bits 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC2FR {
-            bits: u8,
-        }
-        impl IC2FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC2PCSR {
-            bits: u8,
-        }
-        impl IC2PCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ICPCSR {
-            bits: u8,
-        }
-        impl ICPCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2PCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2PCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ICPCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICPCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&self) -> IC2FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&self) -> IC2PCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2PCSR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bits 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&self) -> ICPCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ICPCSR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&mut self) -> _IC2FW {
-                _IC2FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&mut self) -> _IC2PCSW {
-                _IC2PCSW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bits 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&mut self) -> _ICPCSW {
-                _ICPCSW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 2 (output mode)"]
-    pub struct CCMR2_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 2 (output mode)"]
-    pub mod ccmr2_output {
-        #[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::CCMR2_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC4CER {
-            bits: bool,
-        }
-        impl OC4CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC4MR {
-            bits: u8,
-        }
-        impl OC4MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC4PER {
-            bits: bool,
-        }
-        impl OC4PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC4FER {
-            bits: bool,
-        }
-        impl OC4FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4SR {
-            bits: u8,
-        }
-        impl CC4SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC3CER {
-            bits: bool,
-        }
-        impl OC3CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC3MR {
-            bits: u8,
-        }
-        impl OC3MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC3PER {
-            bits: bool,
-        }
-        impl OC3PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC3FER {
-            bits: bool,
-        }
-        impl OC3FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3SR {
-            bits: u8,
-        }
-        impl CC3SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC4CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC4MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC4PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC4FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC3CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC3MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC3PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC3FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 15 - Output compare 4 clear enable"]
-            #[inline]
-            pub fn oc4ce(&self) -> OC4CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4CER { bits }
-            }
-            #[doc = "Bits 12:14 - Output compare 4 mode"]
-            #[inline]
-            pub fn oc4m(&self) -> OC4MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC4MR { bits }
-            }
-            #[doc = "Bit 11 - Output compare 4 preload enable"]
-            #[inline]
-            pub fn oc4pe(&self) -> OC4PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4PER { bits }
-            }
-            #[doc = "Bit 10 - Output compare 4 fast enable"]
-            #[inline]
-            pub fn oc4fe(&self) -> OC4FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4FER { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&self) -> CC4SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC4SR { bits }
-            }
-            #[doc = "Bit 7 - Output compare 3 clear enable"]
-            #[inline]
-            pub fn oc3ce(&self) -> OC3CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3CER { bits }
-            }
-            #[doc = "Bits 4:6 - Output compare 3 mode"]
-            #[inline]
-            pub fn oc3m(&self) -> OC3MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC3MR { bits }
-            }
-            #[doc = "Bit 3 - Output compare 3 preload enable"]
-            #[inline]
-            pub fn oc3pe(&self) -> OC3PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3PER { bits }
-            }
-            #[doc = "Bit 2 - Output compare 3 fast enable"]
-            #[inline]
-            pub fn oc3fe(&self) -> OC3FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3FER { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&self) -> CC3SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC3SR { bits }
-            }
-        }
-        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 15 - Output compare 4 clear enable"]
-            #[inline]
-            pub fn oc4ce(&mut self) -> _OC4CEW {
-                _OC4CEW { w: self }
-            }
-            #[doc = "Bits 12:14 - Output compare 4 mode"]
-            #[inline]
-            pub fn oc4m(&mut self) -> _OC4MW {
-                _OC4MW { w: self }
-            }
-            #[doc = "Bit 11 - Output compare 4 preload enable"]
-            #[inline]
-            pub fn oc4pe(&mut self) -> _OC4PEW {
-                _OC4PEW { w: self }
-            }
-            #[doc = "Bit 10 - Output compare 4 fast enable"]
-            #[inline]
-            pub fn oc4fe(&mut self) -> _OC4FEW {
-                _OC4FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&mut self) -> _CC4SW {
-                _CC4SW { w: self }
-            }
-            #[doc = "Bit 7 - Output compare 3 clear enable"]
-            #[inline]
-            pub fn oc3ce(&mut self) -> _OC3CEW {
-                _OC3CEW { w: self }
-            }
-            #[doc = "Bits 4:6 - Output compare 3 mode"]
-            #[inline]
-            pub fn oc3m(&mut self) -> _OC3MW {
-                _OC3MW { w: self }
-            }
-            #[doc = "Bit 3 - Output compare 3 preload enable"]
-            #[inline]
-            pub fn oc3pe(&mut self) -> _OC3PEW {
-                _OC3PEW { w: self }
-            }
-            #[doc = "Bit 2 - Output compare 3 fast enable"]
-            #[inline]
-            pub fn oc3fe(&mut self) -> _OC3FEW {
-                _OC3FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&mut self) -> _CC3SW {
-                _CC3SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 2 (input mode)"]
-    pub struct CCMR2_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 2 (input mode)"]
-    pub mod ccmr2_input {
-        #[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::CCMR2_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC4FR {
-            bits: u8,
-        }
-        impl IC4FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC4PSCR {
-            bits: u8,
-        }
-        impl IC4PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC4SR {
-            bits: u8,
-        }
-        impl CC4SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC3FR {
-            bits: u8,
-        }
-        impl IC3FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC3PSCR {
-            bits: u8,
-        }
-        impl IC3PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC3SR {
-            bits: u8,
-        }
-        impl CC3SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC4FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC4FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC4PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC4PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC4SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC3FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC3FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC3PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC3PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC3SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 4 filter"]
-            #[inline]
-            pub fn ic4f(&self) -> IC4FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC4FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 4 prescaler"]
-            #[inline]
-            pub fn ic4psc(&self) -> IC4PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC4PSCR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&self) -> CC4SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC4SR { bits }
-            }
-            #[doc = "Bits 4:7 - Input capture 3 filter"]
-            #[inline]
-            pub fn ic3f(&self) -> IC3FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC3FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 3 prescaler"]
-            #[inline]
-            pub fn ic3psc(&self) -> IC3PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC3PSCR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&self) -> CC3SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC3SR { bits }
-            }
-        }
-        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 - Input capture 4 filter"]
-            #[inline]
-            pub fn ic4f(&mut self) -> _IC4FW {
-                _IC4FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 4 prescaler"]
-            #[inline]
-            pub fn ic4psc(&mut self) -> _IC4PSCW {
-                _IC4PSCW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&mut self) -> _CC4SW {
-                _CC4SW { w: self }
-            }
-            #[doc = "Bits 4:7 - Input capture 3 filter"]
-            #[inline]
-            pub fn ic3f(&mut self) -> _IC3FW {
-                _IC3FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 3 prescaler"]
-            #[inline]
-            pub fn ic3psc(&mut self) -> _IC3PSCW {
-                _IC3PSCW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&mut self) -> _CC3SW {
-                _CC3SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC4PR {
-            bits: bool,
-        }
-        impl CC4PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4ER {
-            bits: bool,
-        }
-        impl CC4ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3NPR {
-            bits: bool,
-        }
-        impl CC3NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3NER {
-            bits: bool,
-        }
-        impl CC3NER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3PR {
-            bits: bool,
-        }
-        impl CC3PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3ER {
-            bits: bool,
-        }
-        impl CC3ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2NPR {
-            bits: bool,
-        }
-        impl CC2NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2NER {
-            bits: bool,
-        }
-        impl CC2NER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2PR {
-            bits: bool,
-        }
-        impl CC2PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2ER {
-            bits: bool,
-        }
-        impl CC2ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1NER {
-            bits: bool,
-        }
-        impl CC1NER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC4PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3NEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3NEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2NEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2NEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1NEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc4p(&self) -> CC4PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4PR { bits }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 output enable"]
-            #[inline]
-            pub fn cc4e(&self) -> CC4ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4ER { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3np(&self) -> CC3NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3NPR { bits }
-            }
-            #[doc = "Bit 10 - Capture/Compare 3 complementary output enable"]
-            #[inline]
-            pub fn cc3ne(&self) -> CC3NER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3NER { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3p(&self) -> CC3PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3PR { bits }
-            }
-            #[doc = "Bit 8 - Capture/Compare 3 output enable"]
-            #[inline]
-            pub fn cc3e(&self) -> CC3ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3ER { bits }
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&self) -> CC2NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2NPR { bits }
-            }
-            #[doc = "Bit 6 - Capture/Compare 2 complementary output enable"]
-            #[inline]
-            pub fn cc2ne(&self) -> CC2NER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2NER { bits }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&self) -> CC2PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2PR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&self) -> CC2ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2ER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"]
-            #[inline]
-            pub fn cc1ne(&self) -> CC1NER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NER { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 13 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc4p(&mut self) -> _CC4PW {
-                _CC4PW { w: self }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 output enable"]
-            #[inline]
-            pub fn cc4e(&mut self) -> _CC4EW {
-                _CC4EW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3np(&mut self) -> _CC3NPW {
-                _CC3NPW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/Compare 3 complementary output enable"]
-            #[inline]
-            pub fn cc3ne(&mut self) -> _CC3NEW {
-                _CC3NEW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3p(&mut self) -> _CC3PW {
-                _CC3PW { w: self }
-            }
-            #[doc = "Bit 8 - Capture/Compare 3 output enable"]
-            #[inline]
-            pub fn cc3e(&mut self) -> _CC3EW {
-                _CC3EW { w: self }
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&mut self) -> _CC2NPW {
-                _CC2NPW { w: self }
-            }
-            #[doc = "Bit 6 - Capture/Compare 2 complementary output enable"]
-            #[inline]
-            pub fn cc2ne(&mut self) -> _CC2NEW {
-                _CC2NEW { w: self }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&mut self) -> _CC2PW {
-                _CC2PW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&mut self) -> _CC2EW {
-                _CC2EW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"]
-            #[inline]
-            pub fn cc1ne(&mut self) -> _CC1NEW {
-                _CC1NEW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNTR {
-            bits: u16,
-        }
-        impl CNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&self) -> CNTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNTR { bits }
-            }
-        }
-        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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&mut self) -> _CNTW {
-                _CNTW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARRR {
-            bits: u16,
-        }
-        impl ARRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&self) -> ARRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARRR { bits }
-            }
-        }
-        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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&mut self) -> _ARRW {
-                _ARRW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1R {
-            bits: u16,
-        }
-        impl CCR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&self) -> CCR1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&mut self) -> _CCR1W {
-                _CCR1W { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 2"]
-    pub struct CCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 2"]
-    pub mod ccr2 {
-        #[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::CCR2 {
-            #[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 = r" Value of the field"]
-        pub struct CCR2R {
-            bits: u16,
-        }
-        impl CCR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2(&self) -> CCR2R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2(&mut self) -> _CCR2W {
-                _CCR2W { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 3"]
-    pub struct CCR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 3"]
-    pub mod ccr3 {
-        #[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::CCR3 {
-            #[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 = r" Value of the field"]
-        pub struct CCR3R {
-            bits: u16,
-        }
-        impl CCR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare value"]
-            #[inline]
-            pub fn ccr3(&self) -> CCR3R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR3R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare value"]
-            #[inline]
-            pub fn ccr3(&mut self) -> _CCR3W {
-                _CCR3W { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 4"]
-    pub struct CCR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 4"]
-    pub mod ccr4 {
-        #[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::CCR4 {
-            #[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 = r" Value of the field"]
-        pub struct CCR4R {
-            bits: u16,
-        }
-        impl CCR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare value"]
-            #[inline]
-            pub fn ccr4(&self) -> CCR4R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR4R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare value"]
-            #[inline]
-            pub fn ccr4(&mut self) -> _CCR4W {
-                _CCR4W { w: self }
-            }
-        }
-    }
-    #[doc = "DMA control register"]
-    pub struct DCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA control register"]
-    pub mod dcr {
-        #[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::DCR {
-            #[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 = r" Value of the field"]
-        pub struct DBLR {
-            bits: u8,
-        }
-        impl DBLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DBAR {
-            bits: u8,
-        }
-        impl DBAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 8:12 - DMA burst length"]
-            #[inline]
-            pub fn dbl(&self) -> DBLR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBLR { bits }
-            }
-            #[doc = "Bits 0:4 - DMA base address"]
-            #[inline]
-            pub fn dba(&self) -> DBAR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBAR { bits }
-            }
-        }
-        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 8:12 - DMA burst length"]
-            #[inline]
-            pub fn dbl(&mut self) -> _DBLW {
-                _DBLW { w: self }
-            }
-            #[doc = "Bits 0:4 - DMA base address"]
-            #[inline]
-            pub fn dba(&mut self) -> _DBAW {
-                _DBAW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA address for full transfer"]
-    pub struct DMAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA address for full transfer"]
-    pub mod dmar {
-        #[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::DMAR {
-            #[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 = r" Value of the field"]
-        pub struct DMABR {
-            bits: u16,
-        }
-        impl DMABR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DMABW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMABW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - DMA register for burst accesses"]
-            #[inline]
-            pub fn dmab(&self) -> DMABR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DMABR { bits }
-            }
-        }
-        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 0:15 - DMA register for burst accesses"]
-            #[inline]
-            pub fn dmab(&mut self) -> _DMABW {
-                _DMABW { w: self }
-            }
-        }
-    }
-    #[doc = "repetition counter register"]
-    pub struct RCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "repetition counter register"]
-    pub mod rcr {
-        #[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::RCR {
-            #[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 = r" Value of the field"]
-        pub struct REPR {
-            bits: u8,
-        }
-        impl REPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _REPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _REPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - Repetition counter value"]
-            #[inline]
-            pub fn rep(&self) -> REPR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                REPR { bits }
-            }
-        }
-        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 0:7 - Repetition counter value"]
-            #[inline]
-            pub fn rep(&mut self) -> _REPW {
-                _REPW { w: self }
-            }
-        }
-    }
-    #[doc = "break and dead-time register"]
-    pub struct BDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "break and dead-time register"]
-    pub mod bdtr {
-        #[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::BDTR {
-            #[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 = r" Value of the field"]
-        pub struct MOER {
-            bits: bool,
-        }
-        impl MOER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AOER {
-            bits: bool,
-        }
-        impl AOER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BKPR {
-            bits: bool,
-        }
-        impl BKPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BKER {
-            bits: bool,
-        }
-        impl BKER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OSSRR {
-            bits: bool,
-        }
-        impl OSSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OSSIR {
-            bits: bool,
-        }
-        impl OSSIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LOCKR {
-            bits: u8,
-        }
-        impl LOCKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTGR {
-            bits: u8,
-        }
-        impl DTGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MOEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MOEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AOEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AOEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BKPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BKEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OSSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSSRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OSSIW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSSIW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LOCKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LOCKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 = "Bit 15 - Main output enable"]
-            #[inline]
-            pub fn moe(&self) -> MOER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MOER { bits }
-            }
-            #[doc = "Bit 14 - Automatic output enable"]
-            #[inline]
-            pub fn aoe(&self) -> AOER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AOER { bits }
-            }
-            #[doc = "Bit 13 - Break polarity"]
-            #[inline]
-            pub fn bkp(&self) -> BKPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BKPR { bits }
-            }
-            #[doc = "Bit 12 - Break enable"]
-            #[inline]
-            pub fn bke(&self) -> BKER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BKER { bits }
-            }
-            #[doc = "Bit 11 - Off-state selection for Run mode"]
-            #[inline]
-            pub fn ossr(&self) -> OSSRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OSSRR { bits }
-            }
-            #[doc = "Bit 10 - Off-state selection for Idle mode"]
-            #[inline]
-            pub fn ossi(&self) -> OSSIR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OSSIR { bits }
-            }
-            #[doc = "Bits 8:9 - Lock configuration"]
-            #[inline]
-            pub fn lock(&self) -> LOCKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                LOCKR { bits }
-            }
-            #[doc = "Bits 0:7 - Dead-time generator setup"]
-            #[inline]
-            pub fn dtg(&self) -> DTGR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTGR { bits }
-            }
-        }
-        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 15 - Main output enable"]
-            #[inline]
-            pub fn moe(&mut self) -> _MOEW {
-                _MOEW { w: self }
-            }
-            #[doc = "Bit 14 - Automatic output enable"]
-            #[inline]
-            pub fn aoe(&mut self) -> _AOEW {
-                _AOEW { w: self }
-            }
-            #[doc = "Bit 13 - Break polarity"]
-            #[inline]
-            pub fn bkp(&mut self) -> _BKPW {
-                _BKPW { w: self }
-            }
-            #[doc = "Bit 12 - Break enable"]
-            #[inline]
-            pub fn bke(&mut self) -> _BKEW {
-                _BKEW { w: self }
-            }
-            #[doc = "Bit 11 - Off-state selection for Run mode"]
-            #[inline]
-            pub fn ossr(&mut self) -> _OSSRW {
-                _OSSRW { w: self }
-            }
-            #[doc = "Bit 10 - Off-state selection for Idle mode"]
-            #[inline]
-            pub fn ossi(&mut self) -> _OSSIW {
-                _OSSIW { w: self }
-            }
-            #[doc = "Bits 8:9 - Lock configuration"]
-            #[inline]
-            pub fn lock(&mut self) -> _LOCKW {
-                _LOCKW { w: self }
-            }
-            #[doc = "Bits 0:7 - Dead-time generator setup"]
-            #[inline]
-            pub fn dtg(&mut self) -> _DTGW {
-                _DTGW { w: self }
-            }
-        }
-    }
-}
-#[doc = "TIM8"]
-pub struct TIM8 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM8 {}
-impl TIM8 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim1::RegisterBlock {
-        0x4001_0400 as *const _
-    }
-}
-impl Deref for TIM8 {
-    type Target = tim1::RegisterBlock;
-    fn deref(&self) -> &tim1::RegisterBlock {
-        unsafe { &*TIM8::ptr() }
-    }
-}
-#[doc = "General-purpose-timers"]
-pub struct TIM10 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM10 {}
-impl TIM10 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim10::RegisterBlock {
-        0x4001_4400 as *const _
-    }
-}
-impl Deref for TIM10 {
-    type Target = tim10::RegisterBlock;
-    fn deref(&self) -> &tim10::RegisterBlock {
-        unsafe { &*TIM10::ptr() }
-    }
-}
-#[doc = "General-purpose-timers"]
-pub mod tim10 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        _reserved0: [u8; 8usize],
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register 1 (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        _reserved2: [u8; 4usize],
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ICPCSR {
-            bits: u8,
-        }
-        impl ICPCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ICPCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICPCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&self) -> ICPCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ICPCSR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&mut self) -> _ICPCSW {
-                _ICPCSW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNTR {
-            bits: u16,
-        }
-        impl CNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&self) -> CNTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNTR { bits }
-            }
-        }
-        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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&mut self) -> _CNTW {
-                _CNTW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARRR {
-            bits: u16,
-        }
-        impl ARRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&self) -> ARRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARRR { bits }
-            }
-        }
-        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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&mut self) -> _ARRW {
-                _ARRW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1R {
-            bits: u16,
-        }
-        impl CCR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&self) -> CCR1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&mut self) -> _CCR1W {
-                _CCR1W { w: self }
-            }
-        }
-    }
-}
-#[doc = "General-purpose-timers"]
-pub struct TIM11 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM11 {}
-impl TIM11 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim11::RegisterBlock {
-        0x4001_4800 as *const _
-    }
-}
-impl Deref for TIM11 {
-    type Target = tim11::RegisterBlock;
-    fn deref(&self) -> &tim11::RegisterBlock {
-        unsafe { &*TIM11::ptr() }
-    }
-}
-#[doc = "General-purpose-timers"]
-pub mod tim11 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        _reserved0: [u8; 8usize],
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register 1 (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        _reserved2: [u8; 4usize],
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-        _reserved3: [u8; 24usize],
-        #[doc = "0x50 - option register"]
-        pub or: OR,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ICPCSR {
-            bits: u8,
-        }
-        impl ICPCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ICPCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICPCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&self) -> ICPCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ICPCSR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&mut self) -> _ICPCSW {
-                _ICPCSW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNTR {
-            bits: u16,
-        }
-        impl CNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&self) -> CNTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNTR { bits }
-            }
-        }
-        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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&mut self) -> _CNTW {
-                _CNTW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARRR {
-            bits: u16,
-        }
-        impl ARRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&self) -> ARRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARRR { bits }
-            }
-        }
-        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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&mut self) -> _ARRW {
-                _ARRW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1R {
-            bits: u16,
-        }
-        impl CCR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&self) -> CCR1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&mut self) -> _CCR1W {
-                _CCR1W { w: self }
-            }
-        }
-    }
-    #[doc = "option register"]
-    pub struct OR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "option register"]
-    pub mod or {
-        #[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::OR {
-            #[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 = r" Value of the field"]
-        pub struct RMPR {
-            bits: u8,
-        }
-        impl RMPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RMPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RMPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 0:1 - Input 1 remapping capability"]
-            #[inline]
-            pub fn rmp(&self) -> RMPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RMPR { bits }
-            }
-        }
-        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 0:1 - Input 1 remapping capability"]
-            #[inline]
-            pub fn rmp(&mut self) -> _RMPW {
-                _RMPW { w: self }
-            }
-        }
-    }
-}
-#[doc = "General purpose timers"]
-pub struct TIM2 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM2 {}
-impl TIM2 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim2::RegisterBlock {
-        0x4000_0000 as *const _
-    }
-}
-impl Deref for TIM2 {
-    type Target = tim2::RegisterBlock;
-    fn deref(&self) -> &tim2::RegisterBlock {
-        unsafe { &*TIM2::ptr() }
-    }
-}
-#[doc = "General purpose timers"]
-pub mod tim2 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x08 - slave mode control register"]
-        pub smcr: SMCR,
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register 1 (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        #[doc = "0x1c - capture/compare mode register 2 (output mode)"]
-        pub ccmr2_output: CCMR2_OUTPUT,
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-        #[doc = "0x38 - capture/compare register 2"]
-        pub ccr2: CCR2,
-        #[doc = "0x3c - capture/compare register 3"]
-        pub ccr3: CCR3,
-        #[doc = "0x40 - capture/compare register 4"]
-        pub ccr4: CCR4,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x48 - DMA control register"]
-        pub dcr: DCR,
-        #[doc = "0x4c - DMA address for full transfer"]
-        pub dmar: DMAR,
-        #[doc = "0x50 - TIM5 option register"]
-        pub or: OR,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMSR {
-            bits: u8,
-        }
-        impl CMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DIRR {
-            bits: bool,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPMR {
-            bits: bool,
-        }
-        impl OPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bits 5:6 - Center-aligned mode selection"]
-            #[inline]
-            pub fn cms(&self) -> CMSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CMSR { bits }
-            }
-            #[doc = "Bit 4 - Direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&self) -> OPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPMR { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bits 5:6 - Center-aligned mode selection"]
-            #[inline]
-            pub fn cms(&mut self) -> _CMSW {
-                _CMSW { w: self }
-            }
-            #[doc = "Bit 4 - Direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&mut self) -> _OPMW {
-                _OPMW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct TI1SR {
-            bits: bool,
-        }
-        impl TI1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MMSR {
-            bits: u8,
-        }
-        impl MMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCDSR {
-            bits: bool,
-        }
-        impl CCDSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TI1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TI1SW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCDSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCDSW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - TI1 selection"]
-            #[inline]
-            pub fn ti1s(&self) -> TI1SR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TI1SR { bits }
-            }
-            #[doc = "Bits 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&self) -> MMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MMSR { bits }
-            }
-            #[doc = "Bit 3 - Capture/compare DMA selection"]
-            #[inline]
-            pub fn ccds(&self) -> CCDSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCDSR { bits }
-            }
-        }
-        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 7 - TI1 selection"]
-            #[inline]
-            pub fn ti1s(&mut self) -> _TI1SW {
-                _TI1SW { w: self }
-            }
-            #[doc = "Bits 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&mut self) -> _MMSW {
-                _MMSW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/compare DMA selection"]
-            #[inline]
-            pub fn ccds(&mut self) -> _CCDSW {
-                _CCDSW { w: self }
-            }
-        }
-    }
-    #[doc = "slave mode control register"]
-    pub struct SMCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "slave mode control register"]
-    pub mod smcr {
-        #[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::SMCR {
-            #[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 = r" Value of the field"]
-        pub struct ETPR {
-            bits: bool,
-        }
-        impl ETPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ECER {
-            bits: bool,
-        }
-        impl ECER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ETPSR {
-            bits: u8,
-        }
-        impl ETPSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ETFR {
-            bits: u8,
-        }
-        impl ETFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSMR {
-            bits: bool,
-        }
-        impl MSMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSR {
-            bits: u8,
-        }
-        impl TSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SMSR {
-            bits: u8,
-        }
-        impl SMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ETPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ECEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ETPSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETPSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ETFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 = "Bit 15 - External trigger polarity"]
-            #[inline]
-            pub fn etp(&self) -> ETPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ETPR { bits }
-            }
-            #[doc = "Bit 14 - External clock enable"]
-            #[inline]
-            pub fn ece(&self) -> ECER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ECER { bits }
-            }
-            #[doc = "Bits 12:13 - External trigger prescaler"]
-            #[inline]
-            pub fn etps(&self) -> ETPSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ETPSR { bits }
-            }
-            #[doc = "Bits 8:11 - External trigger filter"]
-            #[inline]
-            pub fn etf(&self) -> ETFR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ETFR { bits }
-            }
-            #[doc = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&self) -> MSMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSMR { bits }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&self) -> TSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TSR { bits }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&self) -> SMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SMSR { bits }
-            }
-        }
-        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 15 - External trigger polarity"]
-            #[inline]
-            pub fn etp(&mut self) -> _ETPW {
-                _ETPW { w: self }
-            }
-            #[doc = "Bit 14 - External clock enable"]
-            #[inline]
-            pub fn ece(&mut self) -> _ECEW {
-                _ECEW { w: self }
-            }
-            #[doc = "Bits 12:13 - External trigger prescaler"]
-            #[inline]
-            pub fn etps(&mut self) -> _ETPSW {
-                _ETPSW { w: self }
-            }
-            #[doc = "Bits 8:11 - External trigger filter"]
-            #[inline]
-            pub fn etf(&mut self) -> _ETFW {
-                _ETFW { w: self }
-            }
-            #[doc = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&mut self) -> _MSMW {
-                _MSMW { w: self }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&mut self) -> _TSW {
-                _TSW { w: self }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&mut self) -> _SMSW {
-                _SMSW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct TDER {
-            bits: bool,
-        }
-        impl TDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4DER {
-            bits: bool,
-        }
-        impl CC4DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3DER {
-            bits: bool,
-        }
-        impl CC3DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2DER {
-            bits: bool,
-        }
-        impl CC2DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1DER {
-            bits: bool,
-        }
-        impl CC1DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDER {
-            bits: bool,
-        }
-        impl UDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIER {
-            bits: bool,
-        }
-        impl TIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4IER {
-            bits: bool,
-        }
-        impl CC4IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3IER {
-            bits: bool,
-        }
-        impl CC3IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IER {
-            bits: bool,
-        }
-        impl CC2IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 14 - Trigger DMA request enable"]
-            #[inline]
-            pub fn tde(&self) -> TDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TDER { bits }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"]
-            #[inline]
-            pub fn cc4de(&self) -> CC4DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4DER { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"]
-            #[inline]
-            pub fn cc3de(&self) -> CC3DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3DER { bits }
-            }
-            #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"]
-            #[inline]
-            pub fn cc2de(&self) -> CC2DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2DER { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"]
-            #[inline]
-            pub fn cc1de(&self) -> CC1DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1DER { bits }
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&self) -> UDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDER { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&self) -> TIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIER { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"]
-            #[inline]
-            pub fn cc4ie(&self) -> CC4IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4IER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"]
-            #[inline]
-            pub fn cc3ie(&self) -> CC3IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3IER { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&self) -> CC2IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IER { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 14 - Trigger DMA request enable"]
-            #[inline]
-            pub fn tde(&mut self) -> _TDEW {
-                _TDEW { w: self }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"]
-            #[inline]
-            pub fn cc4de(&mut self) -> _CC4DEW {
-                _CC4DEW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"]
-            #[inline]
-            pub fn cc3de(&mut self) -> _CC3DEW {
-                _CC3DEW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"]
-            #[inline]
-            pub fn cc2de(&mut self) -> _CC2DEW {
-                _CC2DEW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"]
-            #[inline]
-            pub fn cc1de(&mut self) -> _CC1DEW {
-                _CC1DEW { w: self }
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&mut self) -> _UDEW {
-                _UDEW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&mut self) -> _TIEW {
-                _TIEW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"]
-            #[inline]
-            pub fn cc4ie(&mut self) -> _CC4IEW {
-                _CC4IEW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"]
-            #[inline]
-            pub fn cc3ie(&mut self) -> _CC3IEW {
-                _CC3IEW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&mut self) -> _CC2IEW {
-                _CC2IEW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC4OFR {
-            bits: bool,
-        }
-        impl CC4OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3OFR {
-            bits: bool,
-        }
-        impl CC3OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2OFR {
-            bits: bool,
-        }
-        impl CC2OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIFR {
-            bits: bool,
-        }
-        impl TIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4IFR {
-            bits: bool,
-        }
-        impl CC4IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3IFR {
-            bits: bool,
-        }
-        impl CC3IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IFR {
-            bits: bool,
-        }
-        impl CC2IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC4OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"]
-            #[inline]
-            pub fn cc4of(&self) -> CC4OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4OFR { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
-            #[inline]
-            pub fn cc3of(&self) -> CC3OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3OFR { bits }
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&self) -> CC2OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2OFR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&self) -> TIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIFR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
-            #[inline]
-            pub fn cc4if(&self) -> CC4IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4IFR { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
-            #[inline]
-            pub fn cc3if(&self) -> CC3IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3IFR { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&self) -> CC2IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 12 - Capture/Compare 4 overcapture flag"]
-            #[inline]
-            pub fn cc4of(&mut self) -> _CC4OFW {
-                _CC4OFW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
-            #[inline]
-            pub fn cc3of(&mut self) -> _CC3OFW {
-                _CC3OFW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&mut self) -> _CC2OFW {
-                _CC2OFW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&mut self) -> _TIFW {
-                _TIFW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
-            #[inline]
-            pub fn cc4if(&mut self) -> _CC4IFW {
-                _CC4IFW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
-            #[inline]
-            pub fn cc3if(&mut self) -> _CC3IFW {
-                _CC3IFW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&mut self) -> _CC2IFW {
-                _CC2IFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _TGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 6 - Trigger generation"]
-            #[inline]
-            pub fn tg(&mut self) -> _TGW {
-                _TGW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/compare 4 generation"]
-            #[inline]
-            pub fn cc4g(&mut self) -> _CC4GW {
-                _CC4GW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/compare 3 generation"]
-            #[inline]
-            pub fn cc3g(&mut self) -> _CC3GW {
-                _CC3GW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/compare 2 generation"]
-            #[inline]
-            pub fn cc2g(&mut self) -> _CC2GW {
-                _CC2GW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC2CER {
-            bits: bool,
-        }
-        impl OC2CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2MR {
-            bits: u8,
-        }
-        impl OC2MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC2PER {
-            bits: bool,
-        }
-        impl OC2PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2FER {
-            bits: bool,
-        }
-        impl OC2FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1CER {
-            bits: bool,
-        }
-        impl OC1CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 15 - OC2CE"]
-            #[inline]
-            pub fn oc2ce(&self) -> OC2CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2CER { bits }
-            }
-            #[doc = "Bits 12:14 - OC2M"]
-            #[inline]
-            pub fn oc2m(&self) -> OC2MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC2MR { bits }
-            }
-            #[doc = "Bit 11 - OC2PE"]
-            #[inline]
-            pub fn oc2pe(&self) -> OC2PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2PER { bits }
-            }
-            #[doc = "Bit 10 - OC2FE"]
-            #[inline]
-            pub fn oc2fe(&self) -> OC2FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2FER { bits }
-            }
-            #[doc = "Bits 8:9 - CC2S"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bit 7 - OC1CE"]
-            #[inline]
-            pub fn oc1ce(&self) -> OC1CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1CER { bits }
-            }
-            #[doc = "Bits 4:6 - OC1M"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-            #[doc = "Bit 3 - OC1PE"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bit 2 - OC1FE"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bits 0:1 - CC1S"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 15 - OC2CE"]
-            #[inline]
-            pub fn oc2ce(&mut self) -> _OC2CEW {
-                _OC2CEW { w: self }
-            }
-            #[doc = "Bits 12:14 - OC2M"]
-            #[inline]
-            pub fn oc2m(&mut self) -> _OC2MW {
-                _OC2MW { w: self }
-            }
-            #[doc = "Bit 11 - OC2PE"]
-            #[inline]
-            pub fn oc2pe(&mut self) -> _OC2PEW {
-                _OC2PEW { w: self }
-            }
-            #[doc = "Bit 10 - OC2FE"]
-            #[inline]
-            pub fn oc2fe(&mut self) -> _OC2FEW {
-                _OC2FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - CC2S"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bit 7 - OC1CE"]
-            #[inline]
-            pub fn oc1ce(&mut self) -> _OC1CEW {
-                _OC1CEW { w: self }
-            }
-            #[doc = "Bits 4:6 - OC1M"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-            #[doc = "Bit 3 - OC1PE"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bit 2 - OC1FE"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - CC1S"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC2FR {
-            bits: u8,
-        }
-        impl IC2FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC2PCSR {
-            bits: u8,
-        }
-        impl IC2PCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ICPCSR {
-            bits: u8,
-        }
-        impl ICPCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2PCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2PCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ICPCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICPCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&self) -> IC2FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&self) -> IC2PCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2PCSR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bits 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&self) -> ICPCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ICPCSR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&mut self) -> _IC2FW {
-                _IC2FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&mut self) -> _IC2PCSW {
-                _IC2PCSW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bits 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&mut self) -> _ICPCSW {
-                _ICPCSW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 2 (output mode)"]
-    pub struct CCMR2_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 2 (output mode)"]
-    pub mod ccmr2_output {
-        #[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::CCMR2_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct O24CER {
-            bits: bool,
-        }
-        impl O24CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC4MR {
-            bits: u8,
-        }
-        impl OC4MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC4PER {
-            bits: bool,
-        }
-        impl OC4PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC4FER {
-            bits: bool,
-        }
-        impl OC4FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4SR {
-            bits: u8,
-        }
-        impl CC4SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC3CER {
-            bits: bool,
-        }
-        impl OC3CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC3MR {
-            bits: u8,
-        }
-        impl OC3MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC3PER {
-            bits: bool,
-        }
-        impl OC3PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC3FER {
-            bits: bool,
-        }
-        impl OC3FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3SR {
-            bits: u8,
-        }
-        impl CC3SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _O24CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _O24CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC4MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC4PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC4FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC3CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC3MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC3PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC3FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 15 - O24CE"]
-            #[inline]
-            pub fn o24ce(&self) -> O24CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                O24CER { bits }
-            }
-            #[doc = "Bits 12:14 - OC4M"]
-            #[inline]
-            pub fn oc4m(&self) -> OC4MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC4MR { bits }
-            }
-            #[doc = "Bit 11 - OC4PE"]
-            #[inline]
-            pub fn oc4pe(&self) -> OC4PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4PER { bits }
-            }
-            #[doc = "Bit 10 - OC4FE"]
-            #[inline]
-            pub fn oc4fe(&self) -> OC4FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4FER { bits }
-            }
-            #[doc = "Bits 8:9 - CC4S"]
-            #[inline]
-            pub fn cc4s(&self) -> CC4SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC4SR { bits }
-            }
-            #[doc = "Bit 7 - OC3CE"]
-            #[inline]
-            pub fn oc3ce(&self) -> OC3CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3CER { bits }
-            }
-            #[doc = "Bits 4:6 - OC3M"]
-            #[inline]
-            pub fn oc3m(&self) -> OC3MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC3MR { bits }
-            }
-            #[doc = "Bit 3 - OC3PE"]
-            #[inline]
-            pub fn oc3pe(&self) -> OC3PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3PER { bits }
-            }
-            #[doc = "Bit 2 - OC3FE"]
-            #[inline]
-            pub fn oc3fe(&self) -> OC3FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3FER { bits }
-            }
-            #[doc = "Bits 0:1 - CC3S"]
-            #[inline]
-            pub fn cc3s(&self) -> CC3SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC3SR { bits }
-            }
-        }
-        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 15 - O24CE"]
-            #[inline]
-            pub fn o24ce(&mut self) -> _O24CEW {
-                _O24CEW { w: self }
-            }
-            #[doc = "Bits 12:14 - OC4M"]
-            #[inline]
-            pub fn oc4m(&mut self) -> _OC4MW {
-                _OC4MW { w: self }
-            }
-            #[doc = "Bit 11 - OC4PE"]
-            #[inline]
-            pub fn oc4pe(&mut self) -> _OC4PEW {
-                _OC4PEW { w: self }
-            }
-            #[doc = "Bit 10 - OC4FE"]
-            #[inline]
-            pub fn oc4fe(&mut self) -> _OC4FEW {
-                _OC4FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - CC4S"]
-            #[inline]
-            pub fn cc4s(&mut self) -> _CC4SW {
-                _CC4SW { w: self }
-            }
-            #[doc = "Bit 7 - OC3CE"]
-            #[inline]
-            pub fn oc3ce(&mut self) -> _OC3CEW {
-                _OC3CEW { w: self }
-            }
-            #[doc = "Bits 4:6 - OC3M"]
-            #[inline]
-            pub fn oc3m(&mut self) -> _OC3MW {
-                _OC3MW { w: self }
-            }
-            #[doc = "Bit 3 - OC3PE"]
-            #[inline]
-            pub fn oc3pe(&mut self) -> _OC3PEW {
-                _OC3PEW { w: self }
-            }
-            #[doc = "Bit 2 - OC3FE"]
-            #[inline]
-            pub fn oc3fe(&mut self) -> _OC3FEW {
-                _OC3FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - CC3S"]
-            #[inline]
-            pub fn cc3s(&mut self) -> _CC3SW {
-                _CC3SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 2 (input mode)"]
-    pub struct CCMR2_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 2 (input mode)"]
-    pub mod ccmr2_input {
-        #[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::CCMR2_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC4FR {
-            bits: u8,
-        }
-        impl IC4FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC4PSCR {
-            bits: u8,
-        }
-        impl IC4PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC4SR {
-            bits: u8,
-        }
-        impl CC4SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC3FR {
-            bits: u8,
-        }
-        impl IC3FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC3PSCR {
-            bits: u8,
-        }
-        impl IC3PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC3SR {
-            bits: u8,
-        }
-        impl CC3SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC4FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC4FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC4PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC4PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC4SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC3FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC3FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC3PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC3PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC3SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 4 filter"]
-            #[inline]
-            pub fn ic4f(&self) -> IC4FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC4FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 4 prescaler"]
-            #[inline]
-            pub fn ic4psc(&self) -> IC4PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC4PSCR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&self) -> CC4SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC4SR { bits }
-            }
-            #[doc = "Bits 4:7 - Input capture 3 filter"]
-            #[inline]
-            pub fn ic3f(&self) -> IC3FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC3FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 3 prescaler"]
-            #[inline]
-            pub fn ic3psc(&self) -> IC3PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC3PSCR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&self) -> CC3SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC3SR { bits }
-            }
-        }
-        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 - Input capture 4 filter"]
-            #[inline]
-            pub fn ic4f(&mut self) -> _IC4FW {
-                _IC4FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 4 prescaler"]
-            #[inline]
-            pub fn ic4psc(&mut self) -> _IC4PSCW {
-                _IC4PSCW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&mut self) -> _CC4SW {
-                _CC4SW { w: self }
-            }
-            #[doc = "Bits 4:7 - Input capture 3 filter"]
-            #[inline]
-            pub fn ic3f(&mut self) -> _IC3FW {
-                _IC3FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 3 prescaler"]
-            #[inline]
-            pub fn ic3psc(&mut self) -> _IC3PSCW {
-                _IC3PSCW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&mut self) -> _CC3SW {
-                _CC3SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC4NPR {
-            bits: bool,
-        }
-        impl CC4NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4PR {
-            bits: bool,
-        }
-        impl CC4PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4ER {
-            bits: bool,
-        }
-        impl CC4ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3NPR {
-            bits: bool,
-        }
-        impl CC3NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3PR {
-            bits: bool,
-        }
-        impl CC3PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3ER {
-            bits: bool,
-        }
-        impl CC3ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2NPR {
-            bits: bool,
-        }
-        impl CC2NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2PR {
-            bits: bool,
-        }
-        impl CC2PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2ER {
-            bits: bool,
-        }
-        impl CC2ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC4NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Capture/Compare 4 output Polarity"]
-            #[inline]
-            pub fn cc4np(&self) -> CC4NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4NPR { bits }
-            }
-            #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc4p(&self) -> CC4PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4PR { bits }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 output enable"]
-            #[inline]
-            pub fn cc4e(&self) -> CC4ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4ER { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3np(&self) -> CC3NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3NPR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3p(&self) -> CC3PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3PR { bits }
-            }
-            #[doc = "Bit 8 - Capture/Compare 3 output enable"]
-            #[inline]
-            pub fn cc3e(&self) -> CC3ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3ER { bits }
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&self) -> CC2NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2NPR { bits }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&self) -> CC2PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2PR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&self) -> CC2ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2ER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 15 - Capture/Compare 4 output Polarity"]
-            #[inline]
-            pub fn cc4np(&mut self) -> _CC4NPW {
-                _CC4NPW { w: self }
-            }
-            #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc4p(&mut self) -> _CC4PW {
-                _CC4PW { w: self }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 output enable"]
-            #[inline]
-            pub fn cc4e(&mut self) -> _CC4EW {
-                _CC4EW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3np(&mut self) -> _CC3NPW {
-                _CC3NPW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3p(&mut self) -> _CC3PW {
-                _CC3PW { w: self }
-            }
-            #[doc = "Bit 8 - Capture/Compare 3 output enable"]
-            #[inline]
-            pub fn cc3e(&mut self) -> _CC3EW {
-                _CC3EW { w: self }
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&mut self) -> _CC2NPW {
-                _CC2NPW { w: self }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&mut self) -> _CC2PW {
-                _CC2PW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&mut self) -> _CC2EW {
-                _CC2EW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNT_HR {
-            bits: u16,
-        }
-        impl CNT_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CNT_LR {
-            bits: u16,
-        }
-        impl CNT_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNT_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNT_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNT_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNT_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High counter value"]
-            #[inline]
-            pub fn cnt_h(&self) -> CNT_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNT_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low counter value"]
-            #[inline]
-            pub fn cnt_l(&self) -> CNT_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNT_LR { bits }
-            }
-        }
-        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 16:31 - High counter value"]
-            #[inline]
-            pub fn cnt_h(&mut self) -> _CNT_HW {
-                _CNT_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low counter value"]
-            #[inline]
-            pub fn cnt_l(&mut self) -> _CNT_LW {
-                _CNT_LW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARR_HR {
-            bits: u16,
-        }
-        impl ARR_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARR_LR {
-            bits: u16,
-        }
-        impl ARR_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARR_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARR_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARR_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARR_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Auto-reload value"]
-            #[inline]
-            pub fn arr_h(&self) -> ARR_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARR_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Auto-reload value"]
-            #[inline]
-            pub fn arr_l(&self) -> ARR_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARR_LR { bits }
-            }
-        }
-        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 16:31 - High Auto-reload value"]
-            #[inline]
-            pub fn arr_h(&mut self) -> _ARR_HW {
-                _ARR_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Auto-reload value"]
-            #[inline]
-            pub fn arr_l(&mut self) -> _ARR_LW {
-                _ARR_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1_HR {
-            bits: u16,
-        }
-        impl CCR1_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR1_LR {
-            bits: u16,
-        }
-        impl CCR1_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_h(&self) -> CCR1_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_l(&self) -> CCR1_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_h(&mut self) -> _CCR1_HW {
-                _CCR1_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_l(&mut self) -> _CCR1_LW {
-                _CCR1_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 2"]
-    pub struct CCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 2"]
-    pub mod ccr2 {
-        #[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::CCR2 {
-            #[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 = r" Value of the field"]
-        pub struct CCR2_HR {
-            bits: u16,
-        }
-        impl CCR2_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR2_LR {
-            bits: u16,
-        }
-        impl CCR2_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_h(&self) -> CCR2_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_l(&self) -> CCR2_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_h(&mut self) -> _CCR2_HW {
-                _CCR2_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_l(&mut self) -> _CCR2_LW {
-                _CCR2_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 3"]
-    pub struct CCR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 3"]
-    pub mod ccr3 {
-        #[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::CCR3 {
-            #[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 = r" Value of the field"]
-        pub struct CCR3_HR {
-            bits: u16,
-        }
-        impl CCR3_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR3_LR {
-            bits: u16,
-        }
-        impl CCR3_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR3_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR3_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR3_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR3_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_h(&self) -> CCR3_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR3_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_l(&self) -> CCR3_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR3_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_h(&mut self) -> _CCR3_HW {
-                _CCR3_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_l(&mut self) -> _CCR3_LW {
-                _CCR3_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 4"]
-    pub struct CCR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 4"]
-    pub mod ccr4 {
-        #[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::CCR4 {
-            #[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 = r" Value of the field"]
-        pub struct CCR4_HR {
-            bits: u16,
-        }
-        impl CCR4_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR4_LR {
-            bits: u16,
-        }
-        impl CCR4_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR4_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR4_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR4_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR4_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_h(&self) -> CCR4_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR4_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_l(&self) -> CCR4_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR4_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_h(&mut self) -> _CCR4_HW {
-                _CCR4_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_l(&mut self) -> _CCR4_LW {
-                _CCR4_LW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA control register"]
-    pub struct DCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA control register"]
-    pub mod dcr {
-        #[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::DCR {
-            #[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 = r" Value of the field"]
-        pub struct DBLR {
-            bits: u8,
-        }
-        impl DBLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DBAR {
-            bits: u8,
-        }
-        impl DBAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 8:12 - DMA burst length"]
-            #[inline]
-            pub fn dbl(&self) -> DBLR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBLR { bits }
-            }
-            #[doc = "Bits 0:4 - DMA base address"]
-            #[inline]
-            pub fn dba(&self) -> DBAR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBAR { bits }
-            }
-        }
-        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 8:12 - DMA burst length"]
-            #[inline]
-            pub fn dbl(&mut self) -> _DBLW {
-                _DBLW { w: self }
-            }
-            #[doc = "Bits 0:4 - DMA base address"]
-            #[inline]
-            pub fn dba(&mut self) -> _DBAW {
-                _DBAW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA address for full transfer"]
-    pub struct DMAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA address for full transfer"]
-    pub mod dmar {
-        #[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::DMAR {
-            #[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 = r" Value of the field"]
-        pub struct DMABR {
-            bits: u16,
-        }
-        impl DMABR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DMABW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMABW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - DMA register for burst accesses"]
-            #[inline]
-            pub fn dmab(&self) -> DMABR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DMABR { bits }
-            }
-        }
-        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 0:15 - DMA register for burst accesses"]
-            #[inline]
-            pub fn dmab(&mut self) -> _DMABW {
-                _DMABW { w: self }
-            }
-        }
-    }
-    #[doc = "TIM5 option register"]
-    pub struct OR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "TIM5 option register"]
-    pub mod or {
-        #[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::OR {
-            #[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 = r" Value of the field"]
-        pub struct ITR1_RMPR {
-            bits: u8,
-        }
-        impl ITR1_RMPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ITR1_RMPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITR1_RMPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                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 10:11 - Timer Input 4 remap"]
-            #[inline]
-            pub fn itr1_rmp(&self) -> ITR1_RMPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ITR1_RMPR { bits }
-            }
-        }
-        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 10:11 - Timer Input 4 remap"]
-            #[inline]
-            pub fn itr1_rmp(&mut self) -> _ITR1_RMPW {
-                _ITR1_RMPW { w: self }
-            }
-        }
-    }
-}
-#[doc = "General purpose timers"]
-pub struct TIM3 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM3 {}
-impl TIM3 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim3::RegisterBlock {
-        0x4000_0400 as *const _
-    }
-}
-impl Deref for TIM3 {
-    type Target = tim3::RegisterBlock;
-    fn deref(&self) -> &tim3::RegisterBlock {
-        unsafe { &*TIM3::ptr() }
-    }
-}
-#[doc = "General purpose timers"]
-pub mod tim3 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x08 - slave mode control register"]
-        pub smcr: SMCR,
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register 1 (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        #[doc = "0x1c - capture/compare mode register 2 (output mode)"]
-        pub ccmr2_output: CCMR2_OUTPUT,
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-        #[doc = "0x38 - capture/compare register 2"]
-        pub ccr2: CCR2,
-        #[doc = "0x3c - capture/compare register 3"]
-        pub ccr3: CCR3,
-        #[doc = "0x40 - capture/compare register 4"]
-        pub ccr4: CCR4,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x48 - DMA control register"]
-        pub dcr: DCR,
-        #[doc = "0x4c - DMA address for full transfer"]
-        pub dmar: DMAR,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMSR {
-            bits: u8,
-        }
-        impl CMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DIRR {
-            bits: bool,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPMR {
-            bits: bool,
-        }
-        impl OPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bits 5:6 - Center-aligned mode selection"]
-            #[inline]
-            pub fn cms(&self) -> CMSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CMSR { bits }
-            }
-            #[doc = "Bit 4 - Direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&self) -> OPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPMR { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bits 5:6 - Center-aligned mode selection"]
-            #[inline]
-            pub fn cms(&mut self) -> _CMSW {
-                _CMSW { w: self }
-            }
-            #[doc = "Bit 4 - Direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&mut self) -> _OPMW {
-                _OPMW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct TI1SR {
-            bits: bool,
-        }
-        impl TI1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MMSR {
-            bits: u8,
-        }
-        impl MMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCDSR {
-            bits: bool,
-        }
-        impl CCDSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TI1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TI1SW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCDSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCDSW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - TI1 selection"]
-            #[inline]
-            pub fn ti1s(&self) -> TI1SR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TI1SR { bits }
-            }
-            #[doc = "Bits 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&self) -> MMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MMSR { bits }
-            }
-            #[doc = "Bit 3 - Capture/compare DMA selection"]
-            #[inline]
-            pub fn ccds(&self) -> CCDSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCDSR { bits }
-            }
-        }
-        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 7 - TI1 selection"]
-            #[inline]
-            pub fn ti1s(&mut self) -> _TI1SW {
-                _TI1SW { w: self }
-            }
-            #[doc = "Bits 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&mut self) -> _MMSW {
-                _MMSW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/compare DMA selection"]
-            #[inline]
-            pub fn ccds(&mut self) -> _CCDSW {
-                _CCDSW { w: self }
-            }
-        }
-    }
-    #[doc = "slave mode control register"]
-    pub struct SMCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "slave mode control register"]
-    pub mod smcr {
-        #[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::SMCR {
-            #[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 = r" Value of the field"]
-        pub struct ETPR {
-            bits: bool,
-        }
-        impl ETPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ECER {
-            bits: bool,
-        }
-        impl ECER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ETPSR {
-            bits: u8,
-        }
-        impl ETPSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ETFR {
-            bits: u8,
-        }
-        impl ETFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSMR {
-            bits: bool,
-        }
-        impl MSMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSR {
-            bits: u8,
-        }
-        impl TSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SMSR {
-            bits: u8,
-        }
-        impl SMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ETPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ECEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ETPSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETPSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ETFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 = "Bit 15 - External trigger polarity"]
-            #[inline]
-            pub fn etp(&self) -> ETPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ETPR { bits }
-            }
-            #[doc = "Bit 14 - External clock enable"]
-            #[inline]
-            pub fn ece(&self) -> ECER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ECER { bits }
-            }
-            #[doc = "Bits 12:13 - External trigger prescaler"]
-            #[inline]
-            pub fn etps(&self) -> ETPSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ETPSR { bits }
-            }
-            #[doc = "Bits 8:11 - External trigger filter"]
-            #[inline]
-            pub fn etf(&self) -> ETFR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ETFR { bits }
-            }
-            #[doc = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&self) -> MSMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSMR { bits }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&self) -> TSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TSR { bits }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&self) -> SMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SMSR { bits }
-            }
-        }
-        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 15 - External trigger polarity"]
-            #[inline]
-            pub fn etp(&mut self) -> _ETPW {
-                _ETPW { w: self }
-            }
-            #[doc = "Bit 14 - External clock enable"]
-            #[inline]
-            pub fn ece(&mut self) -> _ECEW {
-                _ECEW { w: self }
-            }
-            #[doc = "Bits 12:13 - External trigger prescaler"]
-            #[inline]
-            pub fn etps(&mut self) -> _ETPSW {
-                _ETPSW { w: self }
-            }
-            #[doc = "Bits 8:11 - External trigger filter"]
-            #[inline]
-            pub fn etf(&mut self) -> _ETFW {
-                _ETFW { w: self }
-            }
-            #[doc = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&mut self) -> _MSMW {
-                _MSMW { w: self }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&mut self) -> _TSW {
-                _TSW { w: self }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&mut self) -> _SMSW {
-                _SMSW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct TDER {
-            bits: bool,
-        }
-        impl TDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4DER {
-            bits: bool,
-        }
-        impl CC4DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3DER {
-            bits: bool,
-        }
-        impl CC3DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2DER {
-            bits: bool,
-        }
-        impl CC2DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1DER {
-            bits: bool,
-        }
-        impl CC1DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDER {
-            bits: bool,
-        }
-        impl UDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIER {
-            bits: bool,
-        }
-        impl TIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4IER {
-            bits: bool,
-        }
-        impl CC4IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3IER {
-            bits: bool,
-        }
-        impl CC3IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IER {
-            bits: bool,
-        }
-        impl CC2IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 14 - Trigger DMA request enable"]
-            #[inline]
-            pub fn tde(&self) -> TDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TDER { bits }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"]
-            #[inline]
-            pub fn cc4de(&self) -> CC4DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4DER { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"]
-            #[inline]
-            pub fn cc3de(&self) -> CC3DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3DER { bits }
-            }
-            #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"]
-            #[inline]
-            pub fn cc2de(&self) -> CC2DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2DER { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"]
-            #[inline]
-            pub fn cc1de(&self) -> CC1DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1DER { bits }
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&self) -> UDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDER { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&self) -> TIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIER { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"]
-            #[inline]
-            pub fn cc4ie(&self) -> CC4IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4IER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"]
-            #[inline]
-            pub fn cc3ie(&self) -> CC3IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3IER { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&self) -> CC2IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IER { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 14 - Trigger DMA request enable"]
-            #[inline]
-            pub fn tde(&mut self) -> _TDEW {
-                _TDEW { w: self }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"]
-            #[inline]
-            pub fn cc4de(&mut self) -> _CC4DEW {
-                _CC4DEW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"]
-            #[inline]
-            pub fn cc3de(&mut self) -> _CC3DEW {
-                _CC3DEW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"]
-            #[inline]
-            pub fn cc2de(&mut self) -> _CC2DEW {
-                _CC2DEW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"]
-            #[inline]
-            pub fn cc1de(&mut self) -> _CC1DEW {
-                _CC1DEW { w: self }
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&mut self) -> _UDEW {
-                _UDEW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&mut self) -> _TIEW {
-                _TIEW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"]
-            #[inline]
-            pub fn cc4ie(&mut self) -> _CC4IEW {
-                _CC4IEW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"]
-            #[inline]
-            pub fn cc3ie(&mut self) -> _CC3IEW {
-                _CC3IEW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&mut self) -> _CC2IEW {
-                _CC2IEW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC4OFR {
-            bits: bool,
-        }
-        impl CC4OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3OFR {
-            bits: bool,
-        }
-        impl CC3OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2OFR {
-            bits: bool,
-        }
-        impl CC2OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIFR {
-            bits: bool,
-        }
-        impl TIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4IFR {
-            bits: bool,
-        }
-        impl CC4IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3IFR {
-            bits: bool,
-        }
-        impl CC3IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IFR {
-            bits: bool,
-        }
-        impl CC2IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC4OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"]
-            #[inline]
-            pub fn cc4of(&self) -> CC4OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4OFR { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
-            #[inline]
-            pub fn cc3of(&self) -> CC3OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3OFR { bits }
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&self) -> CC2OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2OFR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&self) -> TIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIFR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
-            #[inline]
-            pub fn cc4if(&self) -> CC4IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4IFR { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
-            #[inline]
-            pub fn cc3if(&self) -> CC3IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3IFR { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&self) -> CC2IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 12 - Capture/Compare 4 overcapture flag"]
-            #[inline]
-            pub fn cc4of(&mut self) -> _CC4OFW {
-                _CC4OFW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
-            #[inline]
-            pub fn cc3of(&mut self) -> _CC3OFW {
-                _CC3OFW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&mut self) -> _CC2OFW {
-                _CC2OFW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&mut self) -> _TIFW {
-                _TIFW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
-            #[inline]
-            pub fn cc4if(&mut self) -> _CC4IFW {
-                _CC4IFW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
-            #[inline]
-            pub fn cc3if(&mut self) -> _CC3IFW {
-                _CC3IFW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&mut self) -> _CC2IFW {
-                _CC2IFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _TGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 6 - Trigger generation"]
-            #[inline]
-            pub fn tg(&mut self) -> _TGW {
-                _TGW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/compare 4 generation"]
-            #[inline]
-            pub fn cc4g(&mut self) -> _CC4GW {
-                _CC4GW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/compare 3 generation"]
-            #[inline]
-            pub fn cc3g(&mut self) -> _CC3GW {
-                _CC3GW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/compare 2 generation"]
-            #[inline]
-            pub fn cc2g(&mut self) -> _CC2GW {
-                _CC2GW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC2CER {
-            bits: bool,
-        }
-        impl OC2CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2MR {
-            bits: u8,
-        }
-        impl OC2MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC2PER {
-            bits: bool,
-        }
-        impl OC2PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2FER {
-            bits: bool,
-        }
-        impl OC2FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1CER {
-            bits: bool,
-        }
-        impl OC1CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 15 - OC2CE"]
-            #[inline]
-            pub fn oc2ce(&self) -> OC2CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2CER { bits }
-            }
-            #[doc = "Bits 12:14 - OC2M"]
-            #[inline]
-            pub fn oc2m(&self) -> OC2MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC2MR { bits }
-            }
-            #[doc = "Bit 11 - OC2PE"]
-            #[inline]
-            pub fn oc2pe(&self) -> OC2PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2PER { bits }
-            }
-            #[doc = "Bit 10 - OC2FE"]
-            #[inline]
-            pub fn oc2fe(&self) -> OC2FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2FER { bits }
-            }
-            #[doc = "Bits 8:9 - CC2S"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bit 7 - OC1CE"]
-            #[inline]
-            pub fn oc1ce(&self) -> OC1CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1CER { bits }
-            }
-            #[doc = "Bits 4:6 - OC1M"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-            #[doc = "Bit 3 - OC1PE"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bit 2 - OC1FE"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bits 0:1 - CC1S"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 15 - OC2CE"]
-            #[inline]
-            pub fn oc2ce(&mut self) -> _OC2CEW {
-                _OC2CEW { w: self }
-            }
-            #[doc = "Bits 12:14 - OC2M"]
-            #[inline]
-            pub fn oc2m(&mut self) -> _OC2MW {
-                _OC2MW { w: self }
-            }
-            #[doc = "Bit 11 - OC2PE"]
-            #[inline]
-            pub fn oc2pe(&mut self) -> _OC2PEW {
-                _OC2PEW { w: self }
-            }
-            #[doc = "Bit 10 - OC2FE"]
-            #[inline]
-            pub fn oc2fe(&mut self) -> _OC2FEW {
-                _OC2FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - CC2S"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bit 7 - OC1CE"]
-            #[inline]
-            pub fn oc1ce(&mut self) -> _OC1CEW {
-                _OC1CEW { w: self }
-            }
-            #[doc = "Bits 4:6 - OC1M"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-            #[doc = "Bit 3 - OC1PE"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bit 2 - OC1FE"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - CC1S"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC2FR {
-            bits: u8,
-        }
-        impl IC2FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC2PCSR {
-            bits: u8,
-        }
-        impl IC2PCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ICPCSR {
-            bits: u8,
-        }
-        impl ICPCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2PCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2PCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ICPCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICPCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&self) -> IC2FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&self) -> IC2PCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2PCSR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bits 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&self) -> ICPCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ICPCSR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&mut self) -> _IC2FW {
-                _IC2FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&mut self) -> _IC2PCSW {
-                _IC2PCSW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bits 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&mut self) -> _ICPCSW {
-                _ICPCSW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 2 (output mode)"]
-    pub struct CCMR2_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 2 (output mode)"]
-    pub mod ccmr2_output {
-        #[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::CCMR2_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct O24CER {
-            bits: bool,
-        }
-        impl O24CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC4MR {
-            bits: u8,
-        }
-        impl OC4MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC4PER {
-            bits: bool,
-        }
-        impl OC4PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC4FER {
-            bits: bool,
-        }
-        impl OC4FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4SR {
-            bits: u8,
-        }
-        impl CC4SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC3CER {
-            bits: bool,
-        }
-        impl OC3CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC3MR {
-            bits: u8,
-        }
-        impl OC3MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC3PER {
-            bits: bool,
-        }
-        impl OC3PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC3FER {
-            bits: bool,
-        }
-        impl OC3FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3SR {
-            bits: u8,
-        }
-        impl CC3SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _O24CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _O24CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC4MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC4PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC4FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC3CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC3MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC3PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC3FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 15 - O24CE"]
-            #[inline]
-            pub fn o24ce(&self) -> O24CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                O24CER { bits }
-            }
-            #[doc = "Bits 12:14 - OC4M"]
-            #[inline]
-            pub fn oc4m(&self) -> OC4MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC4MR { bits }
-            }
-            #[doc = "Bit 11 - OC4PE"]
-            #[inline]
-            pub fn oc4pe(&self) -> OC4PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4PER { bits }
-            }
-            #[doc = "Bit 10 - OC4FE"]
-            #[inline]
-            pub fn oc4fe(&self) -> OC4FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4FER { bits }
-            }
-            #[doc = "Bits 8:9 - CC4S"]
-            #[inline]
-            pub fn cc4s(&self) -> CC4SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC4SR { bits }
-            }
-            #[doc = "Bit 7 - OC3CE"]
-            #[inline]
-            pub fn oc3ce(&self) -> OC3CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3CER { bits }
-            }
-            #[doc = "Bits 4:6 - OC3M"]
-            #[inline]
-            pub fn oc3m(&self) -> OC3MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC3MR { bits }
-            }
-            #[doc = "Bit 3 - OC3PE"]
-            #[inline]
-            pub fn oc3pe(&self) -> OC3PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3PER { bits }
-            }
-            #[doc = "Bit 2 - OC3FE"]
-            #[inline]
-            pub fn oc3fe(&self) -> OC3FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3FER { bits }
-            }
-            #[doc = "Bits 0:1 - CC3S"]
-            #[inline]
-            pub fn cc3s(&self) -> CC3SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC3SR { bits }
-            }
-        }
-        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 15 - O24CE"]
-            #[inline]
-            pub fn o24ce(&mut self) -> _O24CEW {
-                _O24CEW { w: self }
-            }
-            #[doc = "Bits 12:14 - OC4M"]
-            #[inline]
-            pub fn oc4m(&mut self) -> _OC4MW {
-                _OC4MW { w: self }
-            }
-            #[doc = "Bit 11 - OC4PE"]
-            #[inline]
-            pub fn oc4pe(&mut self) -> _OC4PEW {
-                _OC4PEW { w: self }
-            }
-            #[doc = "Bit 10 - OC4FE"]
-            #[inline]
-            pub fn oc4fe(&mut self) -> _OC4FEW {
-                _OC4FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - CC4S"]
-            #[inline]
-            pub fn cc4s(&mut self) -> _CC4SW {
-                _CC4SW { w: self }
-            }
-            #[doc = "Bit 7 - OC3CE"]
-            #[inline]
-            pub fn oc3ce(&mut self) -> _OC3CEW {
-                _OC3CEW { w: self }
-            }
-            #[doc = "Bits 4:6 - OC3M"]
-            #[inline]
-            pub fn oc3m(&mut self) -> _OC3MW {
-                _OC3MW { w: self }
-            }
-            #[doc = "Bit 3 - OC3PE"]
-            #[inline]
-            pub fn oc3pe(&mut self) -> _OC3PEW {
-                _OC3PEW { w: self }
-            }
-            #[doc = "Bit 2 - OC3FE"]
-            #[inline]
-            pub fn oc3fe(&mut self) -> _OC3FEW {
-                _OC3FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - CC3S"]
-            #[inline]
-            pub fn cc3s(&mut self) -> _CC3SW {
-                _CC3SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 2 (input mode)"]
-    pub struct CCMR2_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 2 (input mode)"]
-    pub mod ccmr2_input {
-        #[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::CCMR2_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC4FR {
-            bits: u8,
-        }
-        impl IC4FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC4PSCR {
-            bits: u8,
-        }
-        impl IC4PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC4SR {
-            bits: u8,
-        }
-        impl CC4SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC3FR {
-            bits: u8,
-        }
-        impl IC3FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC3PSCR {
-            bits: u8,
-        }
-        impl IC3PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC3SR {
-            bits: u8,
-        }
-        impl CC3SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC4FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC4FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC4PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC4PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC4SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC3FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC3FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC3PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC3PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC3SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 4 filter"]
-            #[inline]
-            pub fn ic4f(&self) -> IC4FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC4FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 4 prescaler"]
-            #[inline]
-            pub fn ic4psc(&self) -> IC4PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC4PSCR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&self) -> CC4SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC4SR { bits }
-            }
-            #[doc = "Bits 4:7 - Input capture 3 filter"]
-            #[inline]
-            pub fn ic3f(&self) -> IC3FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC3FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 3 prescaler"]
-            #[inline]
-            pub fn ic3psc(&self) -> IC3PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC3PSCR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&self) -> CC3SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC3SR { bits }
-            }
-        }
-        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 - Input capture 4 filter"]
-            #[inline]
-            pub fn ic4f(&mut self) -> _IC4FW {
-                _IC4FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 4 prescaler"]
-            #[inline]
-            pub fn ic4psc(&mut self) -> _IC4PSCW {
-                _IC4PSCW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&mut self) -> _CC4SW {
-                _CC4SW { w: self }
-            }
-            #[doc = "Bits 4:7 - Input capture 3 filter"]
-            #[inline]
-            pub fn ic3f(&mut self) -> _IC3FW {
-                _IC3FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 3 prescaler"]
-            #[inline]
-            pub fn ic3psc(&mut self) -> _IC3PSCW {
-                _IC3PSCW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&mut self) -> _CC3SW {
-                _CC3SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC4NPR {
-            bits: bool,
-        }
-        impl CC4NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4PR {
-            bits: bool,
-        }
-        impl CC4PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4ER {
-            bits: bool,
-        }
-        impl CC4ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3NPR {
-            bits: bool,
-        }
-        impl CC3NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3PR {
-            bits: bool,
-        }
-        impl CC3PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3ER {
-            bits: bool,
-        }
-        impl CC3ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2NPR {
-            bits: bool,
-        }
-        impl CC2NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2PR {
-            bits: bool,
-        }
-        impl CC2PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2ER {
-            bits: bool,
-        }
-        impl CC2ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC4NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Capture/Compare 4 output Polarity"]
-            #[inline]
-            pub fn cc4np(&self) -> CC4NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4NPR { bits }
-            }
-            #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc4p(&self) -> CC4PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4PR { bits }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 output enable"]
-            #[inline]
-            pub fn cc4e(&self) -> CC4ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4ER { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3np(&self) -> CC3NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3NPR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3p(&self) -> CC3PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3PR { bits }
-            }
-            #[doc = "Bit 8 - Capture/Compare 3 output enable"]
-            #[inline]
-            pub fn cc3e(&self) -> CC3ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3ER { bits }
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&self) -> CC2NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2NPR { bits }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&self) -> CC2PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2PR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&self) -> CC2ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2ER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 15 - Capture/Compare 4 output Polarity"]
-            #[inline]
-            pub fn cc4np(&mut self) -> _CC4NPW {
-                _CC4NPW { w: self }
-            }
-            #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc4p(&mut self) -> _CC4PW {
-                _CC4PW { w: self }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 output enable"]
-            #[inline]
-            pub fn cc4e(&mut self) -> _CC4EW {
-                _CC4EW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3np(&mut self) -> _CC3NPW {
-                _CC3NPW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3p(&mut self) -> _CC3PW {
-                _CC3PW { w: self }
-            }
-            #[doc = "Bit 8 - Capture/Compare 3 output enable"]
-            #[inline]
-            pub fn cc3e(&mut self) -> _CC3EW {
-                _CC3EW { w: self }
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&mut self) -> _CC2NPW {
-                _CC2NPW { w: self }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&mut self) -> _CC2PW {
-                _CC2PW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&mut self) -> _CC2EW {
-                _CC2EW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNT_HR {
-            bits: u16,
-        }
-        impl CNT_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CNT_LR {
-            bits: u16,
-        }
-        impl CNT_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNT_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNT_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNT_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNT_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High counter value"]
-            #[inline]
-            pub fn cnt_h(&self) -> CNT_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNT_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low counter value"]
-            #[inline]
-            pub fn cnt_l(&self) -> CNT_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNT_LR { bits }
-            }
-        }
-        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 16:31 - High counter value"]
-            #[inline]
-            pub fn cnt_h(&mut self) -> _CNT_HW {
-                _CNT_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low counter value"]
-            #[inline]
-            pub fn cnt_l(&mut self) -> _CNT_LW {
-                _CNT_LW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARR_HR {
-            bits: u16,
-        }
-        impl ARR_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARR_LR {
-            bits: u16,
-        }
-        impl ARR_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARR_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARR_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARR_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARR_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Auto-reload value"]
-            #[inline]
-            pub fn arr_h(&self) -> ARR_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARR_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Auto-reload value"]
-            #[inline]
-            pub fn arr_l(&self) -> ARR_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARR_LR { bits }
-            }
-        }
-        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 16:31 - High Auto-reload value"]
-            #[inline]
-            pub fn arr_h(&mut self) -> _ARR_HW {
-                _ARR_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Auto-reload value"]
-            #[inline]
-            pub fn arr_l(&mut self) -> _ARR_LW {
-                _ARR_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1_HR {
-            bits: u16,
-        }
-        impl CCR1_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR1_LR {
-            bits: u16,
-        }
-        impl CCR1_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_h(&self) -> CCR1_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_l(&self) -> CCR1_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_h(&mut self) -> _CCR1_HW {
-                _CCR1_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_l(&mut self) -> _CCR1_LW {
-                _CCR1_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 2"]
-    pub struct CCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 2"]
-    pub mod ccr2 {
-        #[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::CCR2 {
-            #[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 = r" Value of the field"]
-        pub struct CCR2_HR {
-            bits: u16,
-        }
-        impl CCR2_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR2_LR {
-            bits: u16,
-        }
-        impl CCR2_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_h(&self) -> CCR2_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_l(&self) -> CCR2_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_h(&mut self) -> _CCR2_HW {
-                _CCR2_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_l(&mut self) -> _CCR2_LW {
-                _CCR2_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 3"]
-    pub struct CCR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 3"]
-    pub mod ccr3 {
-        #[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::CCR3 {
-            #[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 = r" Value of the field"]
-        pub struct CCR3_HR {
-            bits: u16,
-        }
-        impl CCR3_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR3_LR {
-            bits: u16,
-        }
-        impl CCR3_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR3_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR3_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR3_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR3_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_h(&self) -> CCR3_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR3_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_l(&self) -> CCR3_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR3_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_h(&mut self) -> _CCR3_HW {
-                _CCR3_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_l(&mut self) -> _CCR3_LW {
-                _CCR3_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 4"]
-    pub struct CCR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 4"]
-    pub mod ccr4 {
-        #[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::CCR4 {
-            #[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 = r" Value of the field"]
-        pub struct CCR4_HR {
-            bits: u16,
-        }
-        impl CCR4_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR4_LR {
-            bits: u16,
-        }
-        impl CCR4_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR4_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR4_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR4_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR4_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_h(&self) -> CCR4_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR4_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_l(&self) -> CCR4_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR4_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_h(&mut self) -> _CCR4_HW {
-                _CCR4_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_l(&mut self) -> _CCR4_LW {
-                _CCR4_LW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA control register"]
-    pub struct DCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA control register"]
-    pub mod dcr {
-        #[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::DCR {
-            #[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 = r" Value of the field"]
-        pub struct DBLR {
-            bits: u8,
-        }
-        impl DBLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DBAR {
-            bits: u8,
-        }
-        impl DBAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 8:12 - DMA burst length"]
-            #[inline]
-            pub fn dbl(&self) -> DBLR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBLR { bits }
-            }
-            #[doc = "Bits 0:4 - DMA base address"]
-            #[inline]
-            pub fn dba(&self) -> DBAR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBAR { bits }
-            }
-        }
-        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 8:12 - DMA burst length"]
-            #[inline]
-            pub fn dbl(&mut self) -> _DBLW {
-                _DBLW { w: self }
-            }
-            #[doc = "Bits 0:4 - DMA base address"]
-            #[inline]
-            pub fn dba(&mut self) -> _DBAW {
-                _DBAW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA address for full transfer"]
-    pub struct DMAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA address for full transfer"]
-    pub mod dmar {
-        #[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::DMAR {
-            #[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 = r" Value of the field"]
-        pub struct DMABR {
-            bits: u16,
-        }
-        impl DMABR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DMABW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMABW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - DMA register for burst accesses"]
-            #[inline]
-            pub fn dmab(&self) -> DMABR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DMABR { bits }
-            }
-        }
-        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 0:15 - DMA register for burst accesses"]
-            #[inline]
-            pub fn dmab(&mut self) -> _DMABW {
-                _DMABW { w: self }
-            }
-        }
-    }
-}
-#[doc = "TIM4"]
-pub struct TIM4 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM4 {}
-impl TIM4 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim3::RegisterBlock {
-        0x4000_0800 as *const _
-    }
-}
-impl Deref for TIM4 {
-    type Target = tim3::RegisterBlock;
-    fn deref(&self) -> &tim3::RegisterBlock {
-        unsafe { &*TIM4::ptr() }
-    }
-}
-#[doc = "General-purpose-timers"]
-pub struct TIM5 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM5 {}
-impl TIM5 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim5::RegisterBlock {
-        0x4000_0c00 as *const _
-    }
-}
-impl Deref for TIM5 {
-    type Target = tim5::RegisterBlock;
-    fn deref(&self) -> &tim5::RegisterBlock {
-        unsafe { &*TIM5::ptr() }
-    }
-}
-#[doc = "General-purpose-timers"]
-pub mod tim5 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x08 - slave mode control register"]
-        pub smcr: SMCR,
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register 1 (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        #[doc = "0x1c - capture/compare mode register 2 (output mode)"]
-        pub ccmr2_output: CCMR2_OUTPUT,
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-        #[doc = "0x38 - capture/compare register 2"]
-        pub ccr2: CCR2,
-        #[doc = "0x3c - capture/compare register 3"]
-        pub ccr3: CCR3,
-        #[doc = "0x40 - capture/compare register 4"]
-        pub ccr4: CCR4,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x48 - DMA control register"]
-        pub dcr: DCR,
-        #[doc = "0x4c - DMA address for full transfer"]
-        pub dmar: DMAR,
-        #[doc = "0x50 - TIM5 option register"]
-        pub or: OR,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMSR {
-            bits: u8,
-        }
-        impl CMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DIRR {
-            bits: bool,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPMR {
-            bits: bool,
-        }
-        impl OPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bits 5:6 - Center-aligned mode selection"]
-            #[inline]
-            pub fn cms(&self) -> CMSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CMSR { bits }
-            }
-            #[doc = "Bit 4 - Direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&self) -> OPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPMR { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bits 5:6 - Center-aligned mode selection"]
-            #[inline]
-            pub fn cms(&mut self) -> _CMSW {
-                _CMSW { w: self }
-            }
-            #[doc = "Bit 4 - Direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&mut self) -> _OPMW {
-                _OPMW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct TI1SR {
-            bits: bool,
-        }
-        impl TI1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MMSR {
-            bits: u8,
-        }
-        impl MMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCDSR {
-            bits: bool,
-        }
-        impl CCDSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TI1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TI1SW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCDSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCDSW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - TI1 selection"]
-            #[inline]
-            pub fn ti1s(&self) -> TI1SR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TI1SR { bits }
-            }
-            #[doc = "Bits 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&self) -> MMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MMSR { bits }
-            }
-            #[doc = "Bit 3 - Capture/compare DMA selection"]
-            #[inline]
-            pub fn ccds(&self) -> CCDSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCDSR { bits }
-            }
-        }
-        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 7 - TI1 selection"]
-            #[inline]
-            pub fn ti1s(&mut self) -> _TI1SW {
-                _TI1SW { w: self }
-            }
-            #[doc = "Bits 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&mut self) -> _MMSW {
-                _MMSW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/compare DMA selection"]
-            #[inline]
-            pub fn ccds(&mut self) -> _CCDSW {
-                _CCDSW { w: self }
-            }
-        }
-    }
-    #[doc = "slave mode control register"]
-    pub struct SMCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "slave mode control register"]
-    pub mod smcr {
-        #[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::SMCR {
-            #[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 = r" Value of the field"]
-        pub struct ETPR {
-            bits: bool,
-        }
-        impl ETPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ECER {
-            bits: bool,
-        }
-        impl ECER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ETPSR {
-            bits: u8,
-        }
-        impl ETPSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ETFR {
-            bits: u8,
-        }
-        impl ETFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSMR {
-            bits: bool,
-        }
-        impl MSMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSR {
-            bits: u8,
-        }
-        impl TSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SMSR {
-            bits: u8,
-        }
-        impl SMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ETPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ECEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ETPSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETPSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ETFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ETFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 = "Bit 15 - External trigger polarity"]
-            #[inline]
-            pub fn etp(&self) -> ETPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ETPR { bits }
-            }
-            #[doc = "Bit 14 - External clock enable"]
-            #[inline]
-            pub fn ece(&self) -> ECER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ECER { bits }
-            }
-            #[doc = "Bits 12:13 - External trigger prescaler"]
-            #[inline]
-            pub fn etps(&self) -> ETPSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ETPSR { bits }
-            }
-            #[doc = "Bits 8:11 - External trigger filter"]
-            #[inline]
-            pub fn etf(&self) -> ETFR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ETFR { bits }
-            }
-            #[doc = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&self) -> MSMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSMR { bits }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&self) -> TSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TSR { bits }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&self) -> SMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SMSR { bits }
-            }
-        }
-        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 15 - External trigger polarity"]
-            #[inline]
-            pub fn etp(&mut self) -> _ETPW {
-                _ETPW { w: self }
-            }
-            #[doc = "Bit 14 - External clock enable"]
-            #[inline]
-            pub fn ece(&mut self) -> _ECEW {
-                _ECEW { w: self }
-            }
-            #[doc = "Bits 12:13 - External trigger prescaler"]
-            #[inline]
-            pub fn etps(&mut self) -> _ETPSW {
-                _ETPSW { w: self }
-            }
-            #[doc = "Bits 8:11 - External trigger filter"]
-            #[inline]
-            pub fn etf(&mut self) -> _ETFW {
-                _ETFW { w: self }
-            }
-            #[doc = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&mut self) -> _MSMW {
-                _MSMW { w: self }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&mut self) -> _TSW {
-                _TSW { w: self }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&mut self) -> _SMSW {
-                _SMSW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct TDER {
-            bits: bool,
-        }
-        impl TDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4DER {
-            bits: bool,
-        }
-        impl CC4DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3DER {
-            bits: bool,
-        }
-        impl CC3DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2DER {
-            bits: bool,
-        }
-        impl CC2DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1DER {
-            bits: bool,
-        }
-        impl CC1DER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDER {
-            bits: bool,
-        }
-        impl UDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIER {
-            bits: bool,
-        }
-        impl TIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4IER {
-            bits: bool,
-        }
-        impl CC4IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3IER {
-            bits: bool,
-        }
-        impl CC3IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IER {
-            bits: bool,
-        }
-        impl CC2IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1DEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1DEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 14 - Trigger DMA request enable"]
-            #[inline]
-            pub fn tde(&self) -> TDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TDER { bits }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"]
-            #[inline]
-            pub fn cc4de(&self) -> CC4DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4DER { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"]
-            #[inline]
-            pub fn cc3de(&self) -> CC3DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3DER { bits }
-            }
-            #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"]
-            #[inline]
-            pub fn cc2de(&self) -> CC2DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2DER { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"]
-            #[inline]
-            pub fn cc1de(&self) -> CC1DER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1DER { bits }
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&self) -> UDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDER { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&self) -> TIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIER { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"]
-            #[inline]
-            pub fn cc4ie(&self) -> CC4IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4IER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"]
-            #[inline]
-            pub fn cc3ie(&self) -> CC3IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3IER { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&self) -> CC2IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IER { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 14 - Trigger DMA request enable"]
-            #[inline]
-            pub fn tde(&mut self) -> _TDEW {
-                _TDEW { w: self }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"]
-            #[inline]
-            pub fn cc4de(&mut self) -> _CC4DEW {
-                _CC4DEW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"]
-            #[inline]
-            pub fn cc3de(&mut self) -> _CC3DEW {
-                _CC3DEW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"]
-            #[inline]
-            pub fn cc2de(&mut self) -> _CC2DEW {
-                _CC2DEW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"]
-            #[inline]
-            pub fn cc1de(&mut self) -> _CC1DEW {
-                _CC1DEW { w: self }
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&mut self) -> _UDEW {
-                _UDEW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&mut self) -> _TIEW {
-                _TIEW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"]
-            #[inline]
-            pub fn cc4ie(&mut self) -> _CC4IEW {
-                _CC4IEW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"]
-            #[inline]
-            pub fn cc3ie(&mut self) -> _CC3IEW {
-                _CC3IEW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&mut self) -> _CC2IEW {
-                _CC2IEW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC4OFR {
-            bits: bool,
-        }
-        impl CC4OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3OFR {
-            bits: bool,
-        }
-        impl CC3OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2OFR {
-            bits: bool,
-        }
-        impl CC2OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIFR {
-            bits: bool,
-        }
-        impl TIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4IFR {
-            bits: bool,
-        }
-        impl CC4IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3IFR {
-            bits: bool,
-        }
-        impl CC3IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IFR {
-            bits: bool,
-        }
-        impl CC2IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC4OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"]
-            #[inline]
-            pub fn cc4of(&self) -> CC4OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4OFR { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
-            #[inline]
-            pub fn cc3of(&self) -> CC3OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3OFR { bits }
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&self) -> CC2OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2OFR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&self) -> TIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIFR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
-            #[inline]
-            pub fn cc4if(&self) -> CC4IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4IFR { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
-            #[inline]
-            pub fn cc3if(&self) -> CC3IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3IFR { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&self) -> CC2IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 12 - Capture/Compare 4 overcapture flag"]
-            #[inline]
-            pub fn cc4of(&mut self) -> _CC4OFW {
-                _CC4OFW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
-            #[inline]
-            pub fn cc3of(&mut self) -> _CC3OFW {
-                _CC3OFW { w: self }
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&mut self) -> _CC2OFW {
-                _CC2OFW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&mut self) -> _TIFW {
-                _TIFW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
-            #[inline]
-            pub fn cc4if(&mut self) -> _CC4IFW {
-                _CC4IFW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
-            #[inline]
-            pub fn cc3if(&mut self) -> _CC3IFW {
-                _CC3IFW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&mut self) -> _CC2IFW {
-                _CC2IFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _TGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 6 - Trigger generation"]
-            #[inline]
-            pub fn tg(&mut self) -> _TGW {
-                _TGW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/compare 4 generation"]
-            #[inline]
-            pub fn cc4g(&mut self) -> _CC4GW {
-                _CC4GW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/compare 3 generation"]
-            #[inline]
-            pub fn cc3g(&mut self) -> _CC3GW {
-                _CC3GW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/compare 2 generation"]
-            #[inline]
-            pub fn cc2g(&mut self) -> _CC2GW {
-                _CC2GW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC2CER {
-            bits: bool,
-        }
-        impl OC2CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2MR {
-            bits: u8,
-        }
-        impl OC2MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC2PER {
-            bits: bool,
-        }
-        impl OC2PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2FER {
-            bits: bool,
-        }
-        impl OC2FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1CER {
-            bits: bool,
-        }
-        impl OC1CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 15 - OC2CE"]
-            #[inline]
-            pub fn oc2ce(&self) -> OC2CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2CER { bits }
-            }
-            #[doc = "Bits 12:14 - OC2M"]
-            #[inline]
-            pub fn oc2m(&self) -> OC2MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC2MR { bits }
-            }
-            #[doc = "Bit 11 - OC2PE"]
-            #[inline]
-            pub fn oc2pe(&self) -> OC2PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2PER { bits }
-            }
-            #[doc = "Bit 10 - OC2FE"]
-            #[inline]
-            pub fn oc2fe(&self) -> OC2FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2FER { bits }
-            }
-            #[doc = "Bits 8:9 - CC2S"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bit 7 - OC1CE"]
-            #[inline]
-            pub fn oc1ce(&self) -> OC1CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1CER { bits }
-            }
-            #[doc = "Bits 4:6 - OC1M"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-            #[doc = "Bit 3 - OC1PE"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bit 2 - OC1FE"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bits 0:1 - CC1S"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 15 - OC2CE"]
-            #[inline]
-            pub fn oc2ce(&mut self) -> _OC2CEW {
-                _OC2CEW { w: self }
-            }
-            #[doc = "Bits 12:14 - OC2M"]
-            #[inline]
-            pub fn oc2m(&mut self) -> _OC2MW {
-                _OC2MW { w: self }
-            }
-            #[doc = "Bit 11 - OC2PE"]
-            #[inline]
-            pub fn oc2pe(&mut self) -> _OC2PEW {
-                _OC2PEW { w: self }
-            }
-            #[doc = "Bit 10 - OC2FE"]
-            #[inline]
-            pub fn oc2fe(&mut self) -> _OC2FEW {
-                _OC2FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - CC2S"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bit 7 - OC1CE"]
-            #[inline]
-            pub fn oc1ce(&mut self) -> _OC1CEW {
-                _OC1CEW { w: self }
-            }
-            #[doc = "Bits 4:6 - OC1M"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-            #[doc = "Bit 3 - OC1PE"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bit 2 - OC1FE"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - CC1S"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC2FR {
-            bits: u8,
-        }
-        impl IC2FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC2PCSR {
-            bits: u8,
-        }
-        impl IC2PCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ICPCSR {
-            bits: u8,
-        }
-        impl ICPCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2PCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2PCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ICPCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICPCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&self) -> IC2FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&self) -> IC2PCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2PCSR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bits 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&self) -> ICPCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ICPCSR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&mut self) -> _IC2FW {
-                _IC2FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&mut self) -> _IC2PCSW {
-                _IC2PCSW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bits 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&mut self) -> _ICPCSW {
-                _ICPCSW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 2 (output mode)"]
-    pub struct CCMR2_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 2 (output mode)"]
-    pub mod ccmr2_output {
-        #[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::CCMR2_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct O24CER {
-            bits: bool,
-        }
-        impl O24CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC4MR {
-            bits: u8,
-        }
-        impl OC4MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC4PER {
-            bits: bool,
-        }
-        impl OC4PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC4FER {
-            bits: bool,
-        }
-        impl OC4FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4SR {
-            bits: u8,
-        }
-        impl CC4SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC3CER {
-            bits: bool,
-        }
-        impl OC3CER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC3MR {
-            bits: u8,
-        }
-        impl OC3MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC3PER {
-            bits: bool,
-        }
-        impl OC3PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC3FER {
-            bits: bool,
-        }
-        impl OC3FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3SR {
-            bits: u8,
-        }
-        impl CC3SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _O24CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _O24CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC4MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC4PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC4FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC4FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC3CEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3CEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC3MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC3PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC3FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC3FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 15 - O24CE"]
-            #[inline]
-            pub fn o24ce(&self) -> O24CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                O24CER { bits }
-            }
-            #[doc = "Bits 12:14 - OC4M"]
-            #[inline]
-            pub fn oc4m(&self) -> OC4MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC4MR { bits }
-            }
-            #[doc = "Bit 11 - OC4PE"]
-            #[inline]
-            pub fn oc4pe(&self) -> OC4PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4PER { bits }
-            }
-            #[doc = "Bit 10 - OC4FE"]
-            #[inline]
-            pub fn oc4fe(&self) -> OC4FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC4FER { bits }
-            }
-            #[doc = "Bits 8:9 - CC4S"]
-            #[inline]
-            pub fn cc4s(&self) -> CC4SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC4SR { bits }
-            }
-            #[doc = "Bit 7 - OC3CE"]
-            #[inline]
-            pub fn oc3ce(&self) -> OC3CER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3CER { bits }
-            }
-            #[doc = "Bits 4:6 - OC3M"]
-            #[inline]
-            pub fn oc3m(&self) -> OC3MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC3MR { bits }
-            }
-            #[doc = "Bit 3 - OC3PE"]
-            #[inline]
-            pub fn oc3pe(&self) -> OC3PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3PER { bits }
-            }
-            #[doc = "Bit 2 - OC3FE"]
-            #[inline]
-            pub fn oc3fe(&self) -> OC3FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC3FER { bits }
-            }
-            #[doc = "Bits 0:1 - CC3S"]
-            #[inline]
-            pub fn cc3s(&self) -> CC3SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC3SR { bits }
-            }
-        }
-        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 15 - O24CE"]
-            #[inline]
-            pub fn o24ce(&mut self) -> _O24CEW {
-                _O24CEW { w: self }
-            }
-            #[doc = "Bits 12:14 - OC4M"]
-            #[inline]
-            pub fn oc4m(&mut self) -> _OC4MW {
-                _OC4MW { w: self }
-            }
-            #[doc = "Bit 11 - OC4PE"]
-            #[inline]
-            pub fn oc4pe(&mut self) -> _OC4PEW {
-                _OC4PEW { w: self }
-            }
-            #[doc = "Bit 10 - OC4FE"]
-            #[inline]
-            pub fn oc4fe(&mut self) -> _OC4FEW {
-                _OC4FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - CC4S"]
-            #[inline]
-            pub fn cc4s(&mut self) -> _CC4SW {
-                _CC4SW { w: self }
-            }
-            #[doc = "Bit 7 - OC3CE"]
-            #[inline]
-            pub fn oc3ce(&mut self) -> _OC3CEW {
-                _OC3CEW { w: self }
-            }
-            #[doc = "Bits 4:6 - OC3M"]
-            #[inline]
-            pub fn oc3m(&mut self) -> _OC3MW {
-                _OC3MW { w: self }
-            }
-            #[doc = "Bit 3 - OC3PE"]
-            #[inline]
-            pub fn oc3pe(&mut self) -> _OC3PEW {
-                _OC3PEW { w: self }
-            }
-            #[doc = "Bit 2 - OC3FE"]
-            #[inline]
-            pub fn oc3fe(&mut self) -> _OC3FEW {
-                _OC3FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - CC3S"]
-            #[inline]
-            pub fn cc3s(&mut self) -> _CC3SW {
-                _CC3SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 2 (input mode)"]
-    pub struct CCMR2_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 2 (input mode)"]
-    pub mod ccmr2_input {
-        #[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::CCMR2_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC4FR {
-            bits: u8,
-        }
-        impl IC4FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC4PSCR {
-            bits: u8,
-        }
-        impl IC4PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC4SR {
-            bits: u8,
-        }
-        impl CC4SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC3FR {
-            bits: u8,
-        }
-        impl IC3FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC3PSCR {
-            bits: u8,
-        }
-        impl IC3PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC3SR {
-            bits: u8,
-        }
-        impl CC3SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC4FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC4FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC4PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC4PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC4SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC3FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC3FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC3PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC3PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC3SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 4 filter"]
-            #[inline]
-            pub fn ic4f(&self) -> IC4FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC4FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 4 prescaler"]
-            #[inline]
-            pub fn ic4psc(&self) -> IC4PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC4PSCR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&self) -> CC4SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC4SR { bits }
-            }
-            #[doc = "Bits 4:7 - Input capture 3 filter"]
-            #[inline]
-            pub fn ic3f(&self) -> IC3FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC3FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 3 prescaler"]
-            #[inline]
-            pub fn ic3psc(&self) -> IC3PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC3PSCR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&self) -> CC3SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC3SR { bits }
-            }
-        }
-        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 - Input capture 4 filter"]
-            #[inline]
-            pub fn ic4f(&mut self) -> _IC4FW {
-                _IC4FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 4 prescaler"]
-            #[inline]
-            pub fn ic4psc(&mut self) -> _IC4PSCW {
-                _IC4PSCW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 4 selection"]
-            #[inline]
-            pub fn cc4s(&mut self) -> _CC4SW {
-                _CC4SW { w: self }
-            }
-            #[doc = "Bits 4:7 - Input capture 3 filter"]
-            #[inline]
-            pub fn ic3f(&mut self) -> _IC3FW {
-                _IC3FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 3 prescaler"]
-            #[inline]
-            pub fn ic3psc(&mut self) -> _IC3PSCW {
-                _IC3PSCW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/compare 3 selection"]
-            #[inline]
-            pub fn cc3s(&mut self) -> _CC3SW {
-                _CC3SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC4NPR {
-            bits: bool,
-        }
-        impl CC4NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4PR {
-            bits: bool,
-        }
-        impl CC4PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC4ER {
-            bits: bool,
-        }
-        impl CC4ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3NPR {
-            bits: bool,
-        }
-        impl CC3NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3PR {
-            bits: bool,
-        }
-        impl CC3PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC3ER {
-            bits: bool,
-        }
-        impl CC3ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2NPR {
-            bits: bool,
-        }
-        impl CC2NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2PR {
-            bits: bool,
-        }
-        impl CC2PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2ER {
-            bits: bool,
-        }
-        impl CC2ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC4NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC4EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC4EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC3EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC3EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Capture/Compare 4 output Polarity"]
-            #[inline]
-            pub fn cc4np(&self) -> CC4NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4NPR { bits }
-            }
-            #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc4p(&self) -> CC4PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4PR { bits }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 output enable"]
-            #[inline]
-            pub fn cc4e(&self) -> CC4ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC4ER { bits }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3np(&self) -> CC3NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3NPR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3p(&self) -> CC3PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3PR { bits }
-            }
-            #[doc = "Bit 8 - Capture/Compare 3 output enable"]
-            #[inline]
-            pub fn cc3e(&self) -> CC3ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC3ER { bits }
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&self) -> CC2NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2NPR { bits }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&self) -> CC2PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2PR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&self) -> CC2ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2ER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 15 - Capture/Compare 4 output Polarity"]
-            #[inline]
-            pub fn cc4np(&mut self) -> _CC4NPW {
-                _CC4NPW { w: self }
-            }
-            #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc4p(&mut self) -> _CC4PW {
-                _CC4PW { w: self }
-            }
-            #[doc = "Bit 12 - Capture/Compare 4 output enable"]
-            #[inline]
-            pub fn cc4e(&mut self) -> _CC4EW {
-                _CC4EW { w: self }
-            }
-            #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3np(&mut self) -> _CC3NPW {
-                _CC3NPW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
-            #[inline]
-            pub fn cc3p(&mut self) -> _CC3PW {
-                _CC3PW { w: self }
-            }
-            #[doc = "Bit 8 - Capture/Compare 3 output enable"]
-            #[inline]
-            pub fn cc3e(&mut self) -> _CC3EW {
-                _CC3EW { w: self }
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&mut self) -> _CC2NPW {
-                _CC2NPW { w: self }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&mut self) -> _CC2PW {
-                _CC2PW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&mut self) -> _CC2EW {
-                _CC2EW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNT_HR {
-            bits: u16,
-        }
-        impl CNT_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CNT_LR {
-            bits: u16,
-        }
-        impl CNT_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNT_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNT_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNT_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNT_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High counter value"]
-            #[inline]
-            pub fn cnt_h(&self) -> CNT_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNT_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low counter value"]
-            #[inline]
-            pub fn cnt_l(&self) -> CNT_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNT_LR { bits }
-            }
-        }
-        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 16:31 - High counter value"]
-            #[inline]
-            pub fn cnt_h(&mut self) -> _CNT_HW {
-                _CNT_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low counter value"]
-            #[inline]
-            pub fn cnt_l(&mut self) -> _CNT_LW {
-                _CNT_LW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARR_HR {
-            bits: u16,
-        }
-        impl ARR_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARR_LR {
-            bits: u16,
-        }
-        impl ARR_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARR_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARR_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARR_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARR_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Auto-reload value"]
-            #[inline]
-            pub fn arr_h(&self) -> ARR_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARR_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Auto-reload value"]
-            #[inline]
-            pub fn arr_l(&self) -> ARR_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARR_LR { bits }
-            }
-        }
-        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 16:31 - High Auto-reload value"]
-            #[inline]
-            pub fn arr_h(&mut self) -> _ARR_HW {
-                _ARR_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Auto-reload value"]
-            #[inline]
-            pub fn arr_l(&mut self) -> _ARR_LW {
-                _ARR_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1_HR {
-            bits: u16,
-        }
-        impl CCR1_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR1_LR {
-            bits: u16,
-        }
-        impl CCR1_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_h(&self) -> CCR1_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_l(&self) -> CCR1_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_h(&mut self) -> _CCR1_HW {
-                _CCR1_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1_l(&mut self) -> _CCR1_LW {
-                _CCR1_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 2"]
-    pub struct CCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 2"]
-    pub mod ccr2 {
-        #[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::CCR2 {
-            #[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 = r" Value of the field"]
-        pub struct CCR2_HR {
-            bits: u16,
-        }
-        impl CCR2_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR2_LR {
-            bits: u16,
-        }
-        impl CCR2_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_h(&self) -> CCR2_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_l(&self) -> CCR2_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_h(&mut self) -> _CCR2_HW {
-                _CCR2_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2_l(&mut self) -> _CCR2_LW {
-                _CCR2_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 3"]
-    pub struct CCR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 3"]
-    pub mod ccr3 {
-        #[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::CCR3 {
-            #[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 = r" Value of the field"]
-        pub struct CCR3_HR {
-            bits: u16,
-        }
-        impl CCR3_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR3_LR {
-            bits: u16,
-        }
-        impl CCR3_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR3_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR3_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR3_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR3_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_h(&self) -> CCR3_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR3_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_l(&self) -> CCR3_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR3_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_h(&mut self) -> _CCR3_HW {
-                _CCR3_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr3_l(&mut self) -> _CCR3_LW {
-                _CCR3_LW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 4"]
-    pub struct CCR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 4"]
-    pub mod ccr4 {
-        #[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::CCR4 {
-            #[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 = r" Value of the field"]
-        pub struct CCR4_HR {
-            bits: u16,
-        }
-        impl CCR4_HR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CCR4_LR {
-            bits: u16,
-        }
-        impl CCR4_LR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR4_HW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR4_HW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR4_LW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR4_LW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_h(&self) -> CCR4_HR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR4_HR { bits }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_l(&self) -> CCR4_LR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR4_LR { bits }
-            }
-        }
-        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 16:31 - High Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_h(&mut self) -> _CCR4_HW {
-                _CCR4_HW { w: self }
-            }
-            #[doc = "Bits 0:15 - Low Capture/Compare value"]
-            #[inline]
-            pub fn ccr4_l(&mut self) -> _CCR4_LW {
-                _CCR4_LW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA control register"]
-    pub struct DCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA control register"]
-    pub mod dcr {
-        #[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::DCR {
-            #[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 = r" Value of the field"]
-        pub struct DBLR {
-            bits: u8,
-        }
-        impl DBLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DBAR {
-            bits: u8,
-        }
-        impl DBAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DBAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 8:12 - DMA burst length"]
-            #[inline]
-            pub fn dbl(&self) -> DBLR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBLR { bits }
-            }
-            #[doc = "Bits 0:4 - DMA base address"]
-            #[inline]
-            pub fn dba(&self) -> DBAR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DBAR { bits }
-            }
-        }
-        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 8:12 - DMA burst length"]
-            #[inline]
-            pub fn dbl(&mut self) -> _DBLW {
-                _DBLW { w: self }
-            }
-            #[doc = "Bits 0:4 - DMA base address"]
-            #[inline]
-            pub fn dba(&mut self) -> _DBAW {
-                _DBAW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA address for full transfer"]
-    pub struct DMAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA address for full transfer"]
-    pub mod dmar {
-        #[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::DMAR {
-            #[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 = r" Value of the field"]
-        pub struct DMABR {
-            bits: u16,
-        }
-        impl DMABR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DMABW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMABW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - DMA register for burst accesses"]
-            #[inline]
-            pub fn dmab(&self) -> DMABR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DMABR { bits }
-            }
-        }
-        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 0:15 - DMA register for burst accesses"]
-            #[inline]
-            pub fn dmab(&mut self) -> _DMABW {
-                _DMABW { w: self }
-            }
-        }
-    }
-    #[doc = "TIM5 option register"]
-    pub struct OR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "TIM5 option register"]
-    pub mod or {
-        #[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::OR {
-            #[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 = r" Value of the field"]
-        pub struct IT4_RMPR {
-            bits: u8,
-        }
-        impl IT4_RMPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IT4_RMPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IT4_RMPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                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 6:7 - Timer Input 4 remap"]
-            #[inline]
-            pub fn it4_rmp(&self) -> IT4_RMPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IT4_RMPR { bits }
-            }
-        }
-        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 6:7 - Timer Input 4 remap"]
-            #[inline]
-            pub fn it4_rmp(&mut self) -> _IT4_RMPW {
-                _IT4_RMPW { w: self }
-            }
-        }
-    }
-}
-#[doc = "General purpose timers"]
-pub struct TIM9 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM9 {}
-impl TIM9 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim9::RegisterBlock {
-        0x4001_4000 as *const _
-    }
-}
-impl Deref for TIM9 {
-    type Target = tim9::RegisterBlock;
-    fn deref(&self) -> &tim9::RegisterBlock {
-        unsafe { &*TIM9::ptr() }
-    }
-}
-#[doc = "General purpose timers"]
-pub mod tim9 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x08 - slave mode control register"]
-        pub smcr: SMCR,
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register 1 (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-        #[doc = "0x38 - capture/compare register 2"]
-        pub ccr2: CCR2,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPMR {
-            bits: bool,
-        }
-        impl OPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&self) -> OPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPMR { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&mut self) -> _OPMW {
-                _OPMW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct MMSR {
-            bits: u8,
-        }
-        impl MMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                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 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&self) -> MMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MMSR { bits }
-            }
-        }
-        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 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&mut self) -> _MMSW {
-                _MMSW { w: self }
-            }
-        }
-    }
-    #[doc = "slave mode control register"]
-    pub struct SMCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "slave mode control register"]
-    pub mod smcr {
-        #[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::SMCR {
-            #[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 = r" Value of the field"]
-        pub struct MSMR {
-            bits: bool,
-        }
-        impl MSMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSR {
-            bits: u8,
-        }
-        impl TSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SMSR {
-            bits: u8,
-        }
-        impl SMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&self) -> MSMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSMR { bits }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&self) -> TSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TSR { bits }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&self) -> SMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SMSR { bits }
-            }
-        }
-        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 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&mut self) -> _MSMW {
-                _MSMW { w: self }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&mut self) -> _TSW {
-                _TSW { w: self }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&mut self) -> _SMSW {
-                _SMSW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct TIER {
-            bits: bool,
-        }
-        impl TIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IER {
-            bits: bool,
-        }
-        impl CC2IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&self) -> TIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIER { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&self) -> CC2IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IER { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&mut self) -> _TIEW {
-                _TIEW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&mut self) -> _CC2IEW {
-                _CC2IEW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC2OFR {
-            bits: bool,
-        }
-        impl CC2OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIFR {
-            bits: bool,
-        }
-        impl TIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IFR {
-            bits: bool,
-        }
-        impl CC2IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC2OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&self) -> CC2OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2OFR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&self) -> TIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIFR { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&self) -> CC2IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&mut self) -> _CC2OFW {
-                _CC2OFW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&mut self) -> _TIFW {
-                _TIFW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&mut self) -> _CC2IFW {
-                _CC2IFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _TGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 6 - Trigger generation"]
-            #[inline]
-            pub fn tg(&mut self) -> _TGW {
-                _TGW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/compare 2 generation"]
-            #[inline]
-            pub fn cc2g(&mut self) -> _CC2GW {
-                _CC2GW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC2MR {
-            bits: u8,
-        }
-        impl OC2MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC2PER {
-            bits: bool,
-        }
-        impl OC2PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2FER {
-            bits: bool,
-        }
-        impl OC2FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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:14 - Output Compare 2 mode"]
-            #[inline]
-            pub fn oc2m(&self) -> OC2MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC2MR { bits }
-            }
-            #[doc = "Bit 11 - Output Compare 2 preload enable"]
-            #[inline]
-            pub fn oc2pe(&self) -> OC2PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2PER { bits }
-            }
-            #[doc = "Bit 10 - Output Compare 2 fast enable"]
-            #[inline]
-            pub fn oc2fe(&self) -> OC2FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2FER { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bits 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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:14 - Output Compare 2 mode"]
-            #[inline]
-            pub fn oc2m(&mut self) -> _OC2MW {
-                _OC2MW { w: self }
-            }
-            #[doc = "Bit 11 - Output Compare 2 preload enable"]
-            #[inline]
-            pub fn oc2pe(&mut self) -> _OC2PEW {
-                _OC2PEW { w: self }
-            }
-            #[doc = "Bit 10 - Output Compare 2 fast enable"]
-            #[inline]
-            pub fn oc2fe(&mut self) -> _OC2FEW {
-                _OC2FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bits 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC2FR {
-            bits: u8,
-        }
-        impl IC2FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC2PCSR {
-            bits: u8,
-        }
-        impl IC2PCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ICPCSR {
-            bits: u8,
-        }
-        impl ICPCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2PCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2PCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ICPCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ICPCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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:14 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&self) -> IC2FR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&self) -> IC2PCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2PCSR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bits 4:6 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&self) -> ICPCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ICPCSR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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:14 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&mut self) -> _IC2FW {
-                _IC2FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2pcs(&mut self) -> _IC2PCSW {
-                _IC2PCSW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bits 4:6 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn icpcs(&mut self) -> _ICPCSW {
-                _ICPCSW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC2NPR {
-            bits: bool,
-        }
-        impl CC2NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2PR {
-            bits: bool,
-        }
-        impl CC2PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2ER {
-            bits: bool,
-        }
-        impl CC2ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC2NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&self) -> CC2NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2NPR { bits }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&self) -> CC2PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2PR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&self) -> CC2ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2ER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&mut self) -> _CC2NPW {
-                _CC2NPW { w: self }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&mut self) -> _CC2PW {
-                _CC2PW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&mut self) -> _CC2EW {
-                _CC2EW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNTR {
-            bits: u16,
-        }
-        impl CNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&self) -> CNTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNTR { bits }
-            }
-        }
-        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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&mut self) -> _CNTW {
-                _CNTW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARRR {
-            bits: u16,
-        }
-        impl ARRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&self) -> ARRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARRR { bits }
-            }
-        }
-        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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&mut self) -> _ARRW {
-                _ARRW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1R {
-            bits: u16,
-        }
-        impl CCR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&self) -> CCR1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&mut self) -> _CCR1W {
-                _CCR1W { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 2"]
-    pub struct CCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 2"]
-    pub mod ccr2 {
-        #[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::CCR2 {
-            #[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 = r" Value of the field"]
-        pub struct CCR2R {
-            bits: u16,
-        }
-        impl CCR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2(&self) -> CCR2R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2(&mut self) -> _CCR2W {
-                _CCR2W { w: self }
-            }
-        }
-    }
-}
-#[doc = "Universal synchronous asynchronous receiver transmitter"]
-pub struct USART1 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for USART1 {}
-impl USART1 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4001_1000 as *const _
-    }
-}
-impl Deref for USART1 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*USART1::ptr() }
-    }
-}
-#[doc = "Universal synchronous asynchronous receiver transmitter"]
-pub mod usart1 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Status register"]
-        pub sr: SR,
-        #[doc = "0x04 - Data register"]
-        pub dr: DR,
-        #[doc = "0x08 - Baud rate register"]
-        pub brr: BRR,
-        #[doc = "0x0c - Control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x10 - Control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x14 - Control register 3"]
-        pub cr3: CR3,
-        #[doc = "0x18 - Guard time and prescaler register"]
-        pub gtpr: GTPR,
-    }
-    #[doc = "Status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CTSR {
-            bits: bool,
-        }
-        impl CTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LBDR {
-            bits: bool,
-        }
-        impl LBDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXER {
-            bits: bool,
-        }
-        impl TXER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCR {
-            bits: bool,
-        }
-        impl TCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXNER {
-            bits: bool,
-        }
-        impl RXNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDLER {
-            bits: bool,
-        }
-        impl IDLER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ORER {
-            bits: bool,
-        }
-        impl ORER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NFR {
-            bits: bool,
-        }
-        impl NFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FER {
-            bits: bool,
-        }
-        impl FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PER {
-            bits: bool,
-        }
-        impl PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CTSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LBDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LBDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXNEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXNEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 9 - CTS flag"]
-            #[inline]
-            pub fn cts(&self) -> CTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTSR { bits }
-            }
-            #[doc = "Bit 8 - LIN break detection flag"]
-            #[inline]
-            pub fn lbd(&self) -> LBDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LBDR { bits }
-            }
-            #[doc = "Bit 7 - Transmit data register empty"]
-            #[inline]
-            pub fn txe(&self) -> TXER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXER { bits }
-            }
-            #[doc = "Bit 6 - Transmission complete"]
-            #[inline]
-            pub fn tc(&self) -> TCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCR { bits }
-            }
-            #[doc = "Bit 5 - Read data register not empty"]
-            #[inline]
-            pub fn rxne(&self) -> RXNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXNER { bits }
-            }
-            #[doc = "Bit 4 - IDLE line detected"]
-            #[inline]
-            pub fn idle(&self) -> IDLER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDLER { bits }
-            }
-            #[doc = "Bit 3 - Overrun error"]
-            #[inline]
-            pub fn ore(&self) -> ORER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ORER { bits }
-            }
-            #[doc = "Bit 2 - Noise detected flag"]
-            #[inline]
-            pub fn nf(&self) -> NFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NFR { bits }
-            }
-            #[doc = "Bit 1 - Framing error"]
-            #[inline]
-            pub fn fe(&self) -> FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FER { bits }
-            }
-            #[doc = "Bit 0 - Parity error"]
-            #[inline]
-            pub fn pe(&self) -> PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PER { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x00c0_0000 }
-            }
-            #[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 9 - CTS flag"]
-            #[inline]
-            pub fn cts(&mut self) -> _CTSW {
-                _CTSW { w: self }
-            }
-            #[doc = "Bit 8 - LIN break detection flag"]
-            #[inline]
-            pub fn lbd(&mut self) -> _LBDW {
-                _LBDW { w: self }
-            }
-            #[doc = "Bit 6 - Transmission complete"]
-            #[inline]
-            pub fn tc(&mut self) -> _TCW {
-                _TCW { w: self }
-            }
-            #[doc = "Bit 5 - Read data register not empty"]
-            #[inline]
-            pub fn rxne(&mut self) -> _RXNEW {
-                _RXNEW { w: self }
-            }
-        }
-    }
-    #[doc = "Data register"]
-    pub struct DR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Data register"]
-    pub mod dr {
-        #[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::DR {
-            #[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 = r" Value of the field"]
-        pub struct DRR {
-            bits: u16,
-        }
-        impl DRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x01ff;
-                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 0:8 - Data value"]
-            #[inline]
-            pub fn dr(&self) -> DRR {
-                let bits = {
-                    const MASK: u16 = 0x01ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DRR { bits }
-            }
-        }
-        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 0:8 - Data value"]
-            #[inline]
-            pub fn dr(&mut self) -> _DRW {
-                _DRW { w: self }
-            }
-        }
-    }
-    #[doc = "Baud rate register"]
-    pub struct BRR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Baud rate register"]
-    pub mod brr {
-        #[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::BRR {
-            #[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 = r" Value of the field"]
-        pub struct DIV_MANTISSAR {
-            bits: u16,
-        }
-        impl DIV_MANTISSAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DIV_FRACTIONR {
-            bits: u8,
-        }
-        impl DIV_FRACTIONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DIV_MANTISSAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIV_MANTISSAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DIV_FRACTIONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIV_FRACTIONW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 4:15 - mantissa of USARTDIV"]
-            #[inline]
-            pub fn div_mantissa(&self) -> DIV_MANTISSAR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DIV_MANTISSAR { bits }
-            }
-            #[doc = "Bits 0:3 - fraction of USARTDIV"]
-            #[inline]
-            pub fn div_fraction(&self) -> DIV_FRACTIONR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIV_FRACTIONR { bits }
-            }
-        }
-        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 4:15 - mantissa of USARTDIV"]
-            #[inline]
-            pub fn div_mantissa(&mut self) -> _DIV_MANTISSAW {
-                _DIV_MANTISSAW { w: self }
-            }
-            #[doc = "Bits 0:3 - fraction of USARTDIV"]
-            #[inline]
-            pub fn div_fraction(&mut self) -> _DIV_FRACTIONW {
-                _DIV_FRACTIONW { w: self }
-            }
-        }
-    }
-    #[doc = "Control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct OVER8R {
-            bits: bool,
-        }
-        impl OVER8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UER {
-            bits: bool,
-        }
-        impl UER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MR {
-            bits: bool,
-        }
-        impl MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAKER {
-            bits: bool,
-        }
-        impl WAKER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PCER {
-            bits: bool,
-        }
-        impl PCER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PSR {
-            bits: bool,
-        }
-        impl PSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PEIER {
-            bits: bool,
-        }
-        impl PEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXEIER {
-            bits: bool,
-        }
-        impl TXEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXNEIER {
-            bits: bool,
-        }
-        impl RXNEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDLEIER {
-            bits: bool,
-        }
-        impl IDLEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TER {
-            bits: bool,
-        }
-        impl TER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RER {
-            bits: bool,
-        }
-        impl RER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RWUR {
-            bits: bool,
-        }
-        impl RWUR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SBKR {
-            bits: bool,
-        }
-        impl SBKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OVER8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVER8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAKEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAKEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PCEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PCEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXNEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXNEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IDLEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IDLEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _REW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _REW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RWUW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RWUW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SBKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SBKW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Oversampling mode"]
-            #[inline]
-            pub fn over8(&self) -> OVER8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVER8R { bits }
-            }
-            #[doc = "Bit 13 - USART enable"]
-            #[inline]
-            pub fn ue(&self) -> UER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UER { bits }
-            }
-            #[doc = "Bit 12 - Word length"]
-            #[inline]
-            pub fn m(&self) -> MR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MR { bits }
-            }
-            #[doc = "Bit 11 - Wakeup method"]
-            #[inline]
-            pub fn wake(&self) -> WAKER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAKER { bits }
-            }
-            #[doc = "Bit 10 - Parity control enable"]
-            #[inline]
-            pub fn pce(&self) -> PCER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PCER { bits }
-            }
-            #[doc = "Bit 9 - Parity selection"]
-            #[inline]
-            pub fn ps(&self) -> PSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PSR { bits }
-            }
-            #[doc = "Bit 8 - PE interrupt enable"]
-            #[inline]
-            pub fn peie(&self) -> PEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PEIER { bits }
-            }
-            #[doc = "Bit 7 - TXE interrupt enable"]
-            #[inline]
-            pub fn txeie(&self) -> TXEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXEIER { bits }
-            }
-            #[doc = "Bit 6 - Transmission complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 5 - RXNE interrupt enable"]
-            #[inline]
-            pub fn rxneie(&self) -> RXNEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXNEIER { bits }
-            }
-            #[doc = "Bit 4 - IDLE interrupt enable"]
-            #[inline]
-            pub fn idleie(&self) -> IDLEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDLEIER { bits }
-            }
-            #[doc = "Bit 3 - Transmitter enable"]
-            #[inline]
-            pub fn te(&self) -> TER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TER { bits }
-            }
-            #[doc = "Bit 2 - Receiver enable"]
-            #[inline]
-            pub fn re(&self) -> RER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RER { bits }
-            }
-            #[doc = "Bit 1 - Receiver wakeup"]
-            #[inline]
-            pub fn rwu(&self) -> RWUR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RWUR { bits }
-            }
-            #[doc = "Bit 0 - Send break"]
-            #[inline]
-            pub fn sbk(&self) -> SBKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SBKR { bits }
-            }
-        }
-        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 15 - Oversampling mode"]
-            #[inline]
-            pub fn over8(&mut self) -> _OVER8W {
-                _OVER8W { w: self }
-            }
-            #[doc = "Bit 13 - USART enable"]
-            #[inline]
-            pub fn ue(&mut self) -> _UEW {
-                _UEW { w: self }
-            }
-            #[doc = "Bit 12 - Word length"]
-            #[inline]
-            pub fn m(&mut self) -> _MW {
-                _MW { w: self }
-            }
-            #[doc = "Bit 11 - Wakeup method"]
-            #[inline]
-            pub fn wake(&mut self) -> _WAKEW {
-                _WAKEW { w: self }
-            }
-            #[doc = "Bit 10 - Parity control enable"]
-            #[inline]
-            pub fn pce(&mut self) -> _PCEW {
-                _PCEW { w: self }
-            }
-            #[doc = "Bit 9 - Parity selection"]
-            #[inline]
-            pub fn ps(&mut self) -> _PSW {
-                _PSW { w: self }
-            }
-            #[doc = "Bit 8 - PE interrupt enable"]
-            #[inline]
-            pub fn peie(&mut self) -> _PEIEW {
-                _PEIEW { w: self }
-            }
-            #[doc = "Bit 7 - TXE interrupt enable"]
-            #[inline]
-            pub fn txeie(&mut self) -> _TXEIEW {
-                _TXEIEW { w: self }
-            }
-            #[doc = "Bit 6 - Transmission complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 5 - RXNE interrupt enable"]
-            #[inline]
-            pub fn rxneie(&mut self) -> _RXNEIEW {
-                _RXNEIEW { w: self }
-            }
-            #[doc = "Bit 4 - IDLE interrupt enable"]
-            #[inline]
-            pub fn idleie(&mut self) -> _IDLEIEW {
-                _IDLEIEW { w: self }
-            }
-            #[doc = "Bit 3 - Transmitter enable"]
-            #[inline]
-            pub fn te(&mut self) -> _TEW {
-                _TEW { w: self }
-            }
-            #[doc = "Bit 2 - Receiver enable"]
-            #[inline]
-            pub fn re(&mut self) -> _REW {
-                _REW { w: self }
-            }
-            #[doc = "Bit 1 - Receiver wakeup"]
-            #[inline]
-            pub fn rwu(&mut self) -> _RWUW {
-                _RWUW { w: self }
-            }
-            #[doc = "Bit 0 - Send break"]
-            #[inline]
-            pub fn sbk(&mut self) -> _SBKW {
-                _SBKW { w: self }
-            }
-        }
-    }
-    #[doc = "Control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct LINENR {
-            bits: bool,
-        }
-        impl LINENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STOPR {
-            bits: u8,
-        }
-        impl STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKENR {
-            bits: bool,
-        }
-        impl CLKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CPOLR {
-            bits: bool,
-        }
-        impl CPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CPHAR {
-            bits: bool,
-        }
-        impl CPHAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LBCLR {
-            bits: bool,
-        }
-        impl LBCLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LBDIER {
-            bits: bool,
-        }
-        impl LBDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LBDLR {
-            bits: bool,
-        }
-        impl LBDLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADDR {
-            bits: u8,
-        }
-        impl ADDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _LINENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LINENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STOPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CPHAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CPHAW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LBCLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LBCLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LBDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LBDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LBDLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LBDLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 = "Bit 14 - LIN mode enable"]
-            #[inline]
-            pub fn linen(&self) -> LINENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LINENR { bits }
-            }
-            #[doc = "Bits 12:13 - STOP bits"]
-            #[inline]
-            pub fn stop(&self) -> STOPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                STOPR { bits }
-            }
-            #[doc = "Bit 11 - Clock enable"]
-            #[inline]
-            pub fn clken(&self) -> CLKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLKENR { bits }
-            }
-            #[doc = "Bit 10 - Clock polarity"]
-            #[inline]
-            pub fn cpol(&self) -> CPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CPOLR { bits }
-            }
-            #[doc = "Bit 9 - Clock phase"]
-            #[inline]
-            pub fn cpha(&self) -> CPHAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CPHAR { bits }
-            }
-            #[doc = "Bit 8 - Last bit clock pulse"]
-            #[inline]
-            pub fn lbcl(&self) -> LBCLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LBCLR { bits }
-            }
-            #[doc = "Bit 6 - LIN break detection interrupt enable"]
-            #[inline]
-            pub fn lbdie(&self) -> LBDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LBDIER { bits }
-            }
-            #[doc = "Bit 5 - lin break detection length"]
-            #[inline]
-            pub fn lbdl(&self) -> LBDLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LBDLR { bits }
-            }
-            #[doc = "Bits 0:3 - Address of the USART node"]
-            #[inline]
-            pub fn add(&self) -> ADDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDR { bits }
-            }
-        }
-        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 14 - LIN mode enable"]
-            #[inline]
-            pub fn linen(&mut self) -> _LINENW {
-                _LINENW { w: self }
-            }
-            #[doc = "Bits 12:13 - STOP bits"]
-            #[inline]
-            pub fn stop(&mut self) -> _STOPW {
-                _STOPW { w: self }
-            }
-            #[doc = "Bit 11 - Clock enable"]
-            #[inline]
-            pub fn clken(&mut self) -> _CLKENW {
-                _CLKENW { w: self }
-            }
-            #[doc = "Bit 10 - Clock polarity"]
-            #[inline]
-            pub fn cpol(&mut self) -> _CPOLW {
-                _CPOLW { w: self }
-            }
-            #[doc = "Bit 9 - Clock phase"]
-            #[inline]
-            pub fn cpha(&mut self) -> _CPHAW {
-                _CPHAW { w: self }
-            }
-            #[doc = "Bit 8 - Last bit clock pulse"]
-            #[inline]
-            pub fn lbcl(&mut self) -> _LBCLW {
-                _LBCLW { w: self }
-            }
-            #[doc = "Bit 6 - LIN break detection interrupt enable"]
-            #[inline]
-            pub fn lbdie(&mut self) -> _LBDIEW {
-                _LBDIEW { w: self }
-            }
-            #[doc = "Bit 5 - lin break detection length"]
-            #[inline]
-            pub fn lbdl(&mut self) -> _LBDLW {
-                _LBDLW { w: self }
-            }
-            #[doc = "Bits 0:3 - Address of the USART node"]
-            #[inline]
-            pub fn add(&mut self) -> _ADDW {
-                _ADDW { w: self }
-            }
-        }
-    }
-    #[doc = "Control register 3"]
-    pub struct CR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register 3"]
-    pub mod cr3 {
-        #[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::CR3 {
-            #[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 = r" Value of the field"]
-        pub struct ONEBITR {
-            bits: bool,
-        }
-        impl ONEBITR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTSIER {
-            bits: bool,
-        }
-        impl CTSIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTSER {
-            bits: bool,
-        }
-        impl CTSER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTSER {
-            bits: bool,
-        }
-        impl RTSER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMATR {
-            bits: bool,
-        }
-        impl DMATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMARR {
-            bits: bool,
-        }
-        impl DMARR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCENR {
-            bits: bool,
-        }
-        impl SCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NACKR {
-            bits: bool,
-        }
-        impl NACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HDSELR {
-            bits: bool,
-        }
-        impl HDSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IRLPR {
-            bits: bool,
-        }
-        impl IRLPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IRENR {
-            bits: bool,
-        }
-        impl IRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EIER {
-            bits: bool,
-        }
-        impl EIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ONEBITW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ONEBITW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTSIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTSIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTSEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTSEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTSEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTSEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMATW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMARW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMARW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HDSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HDSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IRLPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IRLPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 11 - One sample bit method enable"]
-            #[inline]
-            pub fn onebit(&self) -> ONEBITR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ONEBITR { bits }
-            }
-            #[doc = "Bit 10 - CTS interrupt enable"]
-            #[inline]
-            pub fn ctsie(&self) -> CTSIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTSIER { bits }
-            }
-            #[doc = "Bit 9 - CTS enable"]
-            #[inline]
-            pub fn ctse(&self) -> CTSER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTSER { bits }
-            }
-            #[doc = "Bit 8 - RTS enable"]
-            #[inline]
-            pub fn rtse(&self) -> RTSER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTSER { bits }
-            }
-            #[doc = "Bit 7 - DMA enable transmitter"]
-            #[inline]
-            pub fn dmat(&self) -> DMATR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMATR { bits }
-            }
-            #[doc = "Bit 6 - DMA enable receiver"]
-            #[inline]
-            pub fn dmar(&self) -> DMARR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMARR { bits }
-            }
-            #[doc = "Bit 5 - Smartcard mode enable"]
-            #[inline]
-            pub fn scen(&self) -> SCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCENR { bits }
-            }
-            #[doc = "Bit 4 - Smartcard NACK enable"]
-            #[inline]
-            pub fn nack(&self) -> NACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NACKR { bits }
-            }
-            #[doc = "Bit 3 - Half-duplex selection"]
-            #[inline]
-            pub fn hdsel(&self) -> HDSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HDSELR { bits }
-            }
-            #[doc = "Bit 2 - IrDA low-power"]
-            #[inline]
-            pub fn irlp(&self) -> IRLPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IRLPR { bits }
-            }
-            #[doc = "Bit 1 - IrDA mode enable"]
-            #[inline]
-            pub fn iren(&self) -> IRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IRENR { bits }
-            }
-            #[doc = "Bit 0 - Error interrupt enable"]
-            #[inline]
-            pub fn eie(&self) -> EIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EIER { bits }
-            }
-        }
-        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 11 - One sample bit method enable"]
-            #[inline]
-            pub fn onebit(&mut self) -> _ONEBITW {
-                _ONEBITW { w: self }
-            }
-            #[doc = "Bit 10 - CTS interrupt enable"]
-            #[inline]
-            pub fn ctsie(&mut self) -> _CTSIEW {
-                _CTSIEW { w: self }
-            }
-            #[doc = "Bit 9 - CTS enable"]
-            #[inline]
-            pub fn ctse(&mut self) -> _CTSEW {
-                _CTSEW { w: self }
-            }
-            #[doc = "Bit 8 - RTS enable"]
-            #[inline]
-            pub fn rtse(&mut self) -> _RTSEW {
-                _RTSEW { w: self }
-            }
-            #[doc = "Bit 7 - DMA enable transmitter"]
-            #[inline]
-            pub fn dmat(&mut self) -> _DMATW {
-                _DMATW { w: self }
-            }
-            #[doc = "Bit 6 - DMA enable receiver"]
-            #[inline]
-            pub fn dmar(&mut self) -> _DMARW {
-                _DMARW { w: self }
-            }
-            #[doc = "Bit 5 - Smartcard mode enable"]
-            #[inline]
-            pub fn scen(&mut self) -> _SCENW {
-                _SCENW { w: self }
-            }
-            #[doc = "Bit 4 - Smartcard NACK enable"]
-            #[inline]
-            pub fn nack(&mut self) -> _NACKW {
-                _NACKW { w: self }
-            }
-            #[doc = "Bit 3 - Half-duplex selection"]
-            #[inline]
-            pub fn hdsel(&mut self) -> _HDSELW {
-                _HDSELW { w: self }
-            }
-            #[doc = "Bit 2 - IrDA low-power"]
-            #[inline]
-            pub fn irlp(&mut self) -> _IRLPW {
-                _IRLPW { w: self }
-            }
-            #[doc = "Bit 1 - IrDA mode enable"]
-            #[inline]
-            pub fn iren(&mut self) -> _IRENW {
-                _IRENW { w: self }
-            }
-            #[doc = "Bit 0 - Error interrupt enable"]
-            #[inline]
-            pub fn eie(&mut self) -> _EIEW {
-                _EIEW { w: self }
-            }
-        }
-    }
-    #[doc = "Guard time and prescaler register"]
-    pub struct GTPR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Guard time and prescaler register"]
-    pub mod gtpr {
-        #[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::GTPR {
-            #[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 = r" Value of the field"]
-        pub struct GTR {
-            bits: u8,
-        }
-        impl GTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSCR {
-            bits: u8,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _GTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 8:15 - Guard time value"]
-            #[inline]
-            pub fn gt(&self) -> GTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                GTR { bits }
-            }
-            #[doc = "Bits 0:7 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSCR { bits }
-            }
-        }
-        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 8:15 - Guard time value"]
-            #[inline]
-            pub fn gt(&mut self) -> _GTW {
-                _GTW { w: self }
-            }
-            #[doc = "Bits 0:7 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-}
-#[doc = "USART2"]
-pub struct USART2 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for USART2 {}
-impl USART2 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4000_4400 as *const _
-    }
-}
-impl Deref for USART2 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*USART2::ptr() }
-    }
-}
-#[doc = "USART6"]
-pub struct USART6 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for USART6 {}
-impl USART6 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4001_1400 as *const _
-    }
-}
-impl Deref for USART6 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*USART6::ptr() }
-    }
-}
-#[doc = "USART3"]
-pub struct USART3 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for USART3 {}
-impl USART3 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4000_4800 as *const _
-    }
-}
-impl Deref for USART3 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*USART3::ptr() }
-    }
-}
-#[doc = "UART4"]
-pub struct UART4 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for UART4 {}
-impl UART4 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4000_4c00 as *const _
-    }
-}
-impl Deref for UART4 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*UART4::ptr() }
-    }
-}
-#[doc = "UART5"]
-pub struct UART5 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for UART5 {}
-impl UART5 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4000_5000 as *const _
-    }
-}
-impl Deref for UART5 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*UART5::ptr() }
-    }
-}
-#[doc = "UART7"]
-pub struct UART7 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for UART7 {}
-impl UART7 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4000_7800 as *const _
-    }
-}
-impl Deref for UART7 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*UART7::ptr() }
-    }
-}
-#[doc = "UART8"]
-pub struct UART8 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for UART8 {}
-impl UART8 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4000_7c00 as *const _
-    }
-}
-impl Deref for UART8 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*UART8::ptr() }
-    }
-}
-#[doc = "UART9"]
-pub struct UART9 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for UART9 {}
-impl UART9 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4001_1800 as *const _
-    }
-}
-impl Deref for UART9 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*UART9::ptr() }
-    }
-}
-#[doc = "UART10"]
-pub struct UART10 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for UART10 {}
-impl UART10 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const usart1::RegisterBlock {
-        0x4001_1c00 as *const _
-    }
-}
-impl Deref for UART10 {
-    type Target = usart1::RegisterBlock;
-    fn deref(&self) -> &usart1::RegisterBlock {
-        unsafe { &*UART10::ptr() }
-    }
-}
-#[doc = "Window watchdog"]
-pub struct WWDG {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for WWDG {}
-impl WWDG {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const wwdg::RegisterBlock {
-        0x4000_2c00 as *const _
-    }
-}
-impl Deref for WWDG {
-    type Target = wwdg::RegisterBlock;
-    fn deref(&self) -> &wwdg::RegisterBlock {
-        unsafe { &*WWDG::ptr() }
-    }
-}
-#[doc = "Window watchdog"]
-pub mod wwdg {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Control register"]
-        pub cr: CR,
-        #[doc = "0x04 - Configuration register"]
-        pub cfr: CFR,
-        #[doc = "0x08 - Status register"]
-        pub sr: SR,
-    }
-    #[doc = "Control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct WDGAR {
-            bits: bool,
-        }
-        impl WDGAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TR {
-            bits: u8,
-        }
-        impl TR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDGAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDGAW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                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 = "Bit 7 - Activation bit"]
-            #[inline]
-            pub fn wdga(&self) -> WDGAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WDGAR { bits }
-            }
-            #[doc = "Bits 0:6 - 7-bit counter (MSB to LSB)"]
-            #[inline]
-            pub fn t(&self) -> TR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x7f }
-            }
-            #[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 7 - Activation bit"]
-            #[inline]
-            pub fn wdga(&mut self) -> _WDGAW {
-                _WDGAW { w: self }
-            }
-            #[doc = "Bits 0:6 - 7-bit counter (MSB to LSB)"]
-            #[inline]
-            pub fn t(&mut self) -> _TW {
-                _TW { w: self }
-            }
-        }
-    }
-    #[doc = "Configuration register"]
-    pub struct CFR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Configuration register"]
-    pub mod cfr {
-        #[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::CFR {
-            #[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 = r" Value of the field"]
-        pub struct EWIR {
-            bits: bool,
-        }
-        impl EWIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WDGTB1R {
-            bits: bool,
-        }
-        impl WDGTB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WDGTB0R {
-            bits: bool,
-        }
-        impl WDGTB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WR {
-            bits: u8,
-        }
-        impl WR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EWIW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EWIW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WDGTB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDGTB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WDGTB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDGTB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                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 = "Bit 9 - Early wakeup interrupt"]
-            #[inline]
-            pub fn ewi(&self) -> EWIR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EWIR { bits }
-            }
-            #[doc = "Bit 8 - Timer base"]
-            #[inline]
-            pub fn wdgtb1(&self) -> WDGTB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WDGTB1R { bits }
-            }
-            #[doc = "Bit 7 - Timer base"]
-            #[inline]
-            pub fn wdgtb0(&self) -> WDGTB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WDGTB0R { bits }
-            }
-            #[doc = "Bits 0:6 - 7-bit window value"]
-            #[inline]
-            pub fn w(&self) -> WR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                WR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x7f }
-            }
-            #[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 9 - Early wakeup interrupt"]
-            #[inline]
-            pub fn ewi(&mut self) -> _EWIW {
-                _EWIW { w: self }
-            }
-            #[doc = "Bit 8 - Timer base"]
-            #[inline]
-            pub fn wdgtb1(&mut self) -> _WDGTB1W {
-                _WDGTB1W { w: self }
-            }
-            #[doc = "Bit 7 - Timer base"]
-            #[inline]
-            pub fn wdgtb0(&mut self) -> _WDGTB0W {
-                _WDGTB0W { w: self }
-            }
-            #[doc = "Bits 0:6 - 7-bit window value"]
-            #[inline]
-            pub fn w(&mut self) -> _WW {
-                _WW { w: self }
-            }
-        }
-    }
-    #[doc = "Status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct EWIFR {
-            bits: bool,
-        }
-        impl EWIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _EWIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EWIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Early wakeup interrupt flag"]
-            #[inline]
-            pub fn ewif(&self) -> EWIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EWIFR { bits }
-            }
-        }
-        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 - Early wakeup interrupt flag"]
-            #[inline]
-            pub fn ewif(&mut self) -> _EWIFW {
-                _EWIFW { w: self }
-            }
-        }
-    }
-}
-#[doc = "DMA controller"]
-pub struct DMA2 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for DMA2 {}
-impl DMA2 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const dma2::RegisterBlock {
-        0x4002_6400 as *const _
-    }
-}
-impl Deref for DMA2 {
-    type Target = dma2::RegisterBlock;
-    fn deref(&self) -> &dma2::RegisterBlock {
-        unsafe { &*DMA2::ptr() }
-    }
-}
-#[doc = "DMA controller"]
-pub mod dma2 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - low interrupt status register"]
-        pub lisr: LISR,
-        #[doc = "0x04 - high interrupt status register"]
-        pub hisr: HISR,
-        #[doc = "0x08 - low interrupt flag clear register"]
-        pub lifcr: LIFCR,
-        #[doc = "0x0c - high interrupt flag clear register"]
-        pub hifcr: HIFCR,
-        #[doc = "0x10 - stream x configuration register"]
-        pub s0cr: S0CR,
-        #[doc = "0x14 - stream x number of data register"]
-        pub s0ndtr: S0NDTR,
-        #[doc = "0x18 - stream x peripheral address register"]
-        pub s0par: S0PAR,
-        #[doc = "0x1c - stream x memory 0 address register"]
-        pub s0m0ar: S0M0AR,
-        #[doc = "0x20 - stream x memory 1 address register"]
-        pub s0m1ar: S0M1AR,
-        #[doc = "0x24 - stream x FIFO control register"]
-        pub s0fcr: S0FCR,
-        #[doc = "0x28 - stream x configuration register"]
-        pub s1cr: S1CR,
-        #[doc = "0x2c - stream x number of data register"]
-        pub s1ndtr: S1NDTR,
-        #[doc = "0x30 - stream x peripheral address register"]
-        pub s1par: S1PAR,
-        #[doc = "0x34 - stream x memory 0 address register"]
-        pub s1m0ar: S1M0AR,
-        #[doc = "0x38 - stream x memory 1 address register"]
-        pub s1m1ar: S1M1AR,
-        #[doc = "0x3c - stream x FIFO control register"]
-        pub s1fcr: S1FCR,
-        #[doc = "0x40 - stream x configuration register"]
-        pub s2cr: S2CR,
-        #[doc = "0x44 - stream x number of data register"]
-        pub s2ndtr: S2NDTR,
-        #[doc = "0x48 - stream x peripheral address register"]
-        pub s2par: S2PAR,
-        #[doc = "0x4c - stream x memory 0 address register"]
-        pub s2m0ar: S2M0AR,
-        #[doc = "0x50 - stream x memory 1 address register"]
-        pub s2m1ar: S2M1AR,
-        #[doc = "0x54 - stream x FIFO control register"]
-        pub s2fcr: S2FCR,
-        #[doc = "0x58 - stream x configuration register"]
-        pub s3cr: S3CR,
-        #[doc = "0x5c - stream x number of data register"]
-        pub s3ndtr: S3NDTR,
-        #[doc = "0x60 - stream x peripheral address register"]
-        pub s3par: S3PAR,
-        #[doc = "0x64 - stream x memory 0 address register"]
-        pub s3m0ar: S3M0AR,
-        #[doc = "0x68 - stream x memory 1 address register"]
-        pub s3m1ar: S3M1AR,
-        #[doc = "0x6c - stream x FIFO control register"]
-        pub s3fcr: S3FCR,
-        #[doc = "0x70 - stream x configuration register"]
-        pub s4cr: S4CR,
-        #[doc = "0x74 - stream x number of data register"]
-        pub s4ndtr: S4NDTR,
-        #[doc = "0x78 - stream x peripheral address register"]
-        pub s4par: S4PAR,
-        #[doc = "0x7c - stream x memory 0 address register"]
-        pub s4m0ar: S4M0AR,
-        #[doc = "0x80 - stream x memory 1 address register"]
-        pub s4m1ar: S4M1AR,
-        #[doc = "0x84 - stream x FIFO control register"]
-        pub s4fcr: S4FCR,
-        #[doc = "0x88 - stream x configuration register"]
-        pub s5cr: S5CR,
-        #[doc = "0x8c - stream x number of data register"]
-        pub s5ndtr: S5NDTR,
-        #[doc = "0x90 - stream x peripheral address register"]
-        pub s5par: S5PAR,
-        #[doc = "0x94 - stream x memory 0 address register"]
-        pub s5m0ar: S5M0AR,
-        #[doc = "0x98 - stream x memory 1 address register"]
-        pub s5m1ar: S5M1AR,
-        #[doc = "0x9c - stream x FIFO control register"]
-        pub s5fcr: S5FCR,
-        #[doc = "0xa0 - stream x configuration register"]
-        pub s6cr: S6CR,
-        #[doc = "0xa4 - stream x number of data register"]
-        pub s6ndtr: S6NDTR,
-        #[doc = "0xa8 - stream x peripheral address register"]
-        pub s6par: S6PAR,
-        #[doc = "0xac - stream x memory 0 address register"]
-        pub s6m0ar: S6M0AR,
-        #[doc = "0xb0 - stream x memory 1 address register"]
-        pub s6m1ar: S6M1AR,
-        #[doc = "0xb4 - stream x FIFO control register"]
-        pub s6fcr: S6FCR,
-        #[doc = "0xb8 - stream x configuration register"]
-        pub s7cr: S7CR,
-        #[doc = "0xbc - stream x number of data register"]
-        pub s7ndtr: S7NDTR,
-        #[doc = "0xc0 - stream x peripheral address register"]
-        pub s7par: S7PAR,
-        #[doc = "0xc4 - stream x memory 0 address register"]
-        pub s7m0ar: S7M0AR,
-        #[doc = "0xc8 - stream x memory 1 address register"]
-        pub s7m1ar: S7M1AR,
-        #[doc = "0xcc - stream x FIFO control register"]
-        pub s7fcr: S7FCR,
-    }
-    #[doc = "low interrupt status register"]
-    pub struct LISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "low interrupt status register"]
-    pub mod lisr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::LISR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TCIF3R {
-            bits: bool,
-        }
-        impl TCIF3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIF3R {
-            bits: bool,
-        }
-        impl HTIF3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIF3R {
-            bits: bool,
-        }
-        impl TEIF3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIF3R {
-            bits: bool,
-        }
-        impl DMEIF3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FEIF3R {
-            bits: bool,
-        }
-        impl FEIF3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIF2R {
-            bits: bool,
-        }
-        impl TCIF2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIF2R {
-            bits: bool,
-        }
-        impl HTIF2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIF2R {
-            bits: bool,
-        }
-        impl TEIF2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIF2R {
-            bits: bool,
-        }
-        impl DMEIF2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FEIF2R {
-            bits: bool,
-        }
-        impl FEIF2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIF1R {
-            bits: bool,
-        }
-        impl TCIF1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIF1R {
-            bits: bool,
-        }
-        impl HTIF1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIF1R {
-            bits: bool,
-        }
-        impl TEIF1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIF1R {
-            bits: bool,
-        }
-        impl DMEIF1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FEIF1R {
-            bits: bool,
-        }
-        impl FEIF1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIF0R {
-            bits: bool,
-        }
-        impl TCIF0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIF0R {
-            bits: bool,
-        }
-        impl HTIF0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIF0R {
-            bits: bool,
-        }
-        impl TEIF0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIF0R {
-            bits: bool,
-        }
-        impl DMEIF0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FEIF0R {
-            bits: bool,
-        }
-        impl FEIF0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 27 - Stream x transfer complete interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn tcif3(&self) -> TCIF3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIF3R { bits }
-            }
-            #[doc = "Bit 26 - Stream x half transfer interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn htif3(&self) -> HTIF3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIF3R { bits }
-            }
-            #[doc = "Bit 25 - Stream x transfer error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn teif3(&self) -> TEIF3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIF3R { bits }
-            }
-            #[doc = "Bit 24 - Stream x direct mode error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn dmeif3(&self) -> DMEIF3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIF3R { bits }
-            }
-            #[doc = "Bit 22 - Stream x FIFO error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn feif3(&self) -> FEIF3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIF3R { bits }
-            }
-            #[doc = "Bit 21 - Stream x transfer complete interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn tcif2(&self) -> TCIF2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIF2R { bits }
-            }
-            #[doc = "Bit 20 - Stream x half transfer interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn htif2(&self) -> HTIF2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIF2R { bits }
-            }
-            #[doc = "Bit 19 - Stream x transfer error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn teif2(&self) -> TEIF2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIF2R { bits }
-            }
-            #[doc = "Bit 18 - Stream x direct mode error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn dmeif2(&self) -> DMEIF2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIF2R { bits }
-            }
-            #[doc = "Bit 16 - Stream x FIFO error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn feif2(&self) -> FEIF2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIF2R { bits }
-            }
-            #[doc = "Bit 11 - Stream x transfer complete interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn tcif1(&self) -> TCIF1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIF1R { bits }
-            }
-            #[doc = "Bit 10 - Stream x half transfer interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn htif1(&self) -> HTIF1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIF1R { bits }
-            }
-            #[doc = "Bit 9 - Stream x transfer error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn teif1(&self) -> TEIF1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIF1R { bits }
-            }
-            #[doc = "Bit 8 - Stream x direct mode error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn dmeif1(&self) -> DMEIF1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIF1R { bits }
-            }
-            #[doc = "Bit 6 - Stream x FIFO error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn feif1(&self) -> FEIF1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIF1R { bits }
-            }
-            #[doc = "Bit 5 - Stream x transfer complete interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn tcif0(&self) -> TCIF0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIF0R { bits }
-            }
-            #[doc = "Bit 4 - Stream x half transfer interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn htif0(&self) -> HTIF0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIF0R { bits }
-            }
-            #[doc = "Bit 3 - Stream x transfer error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn teif0(&self) -> TEIF0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIF0R { bits }
-            }
-            #[doc = "Bit 2 - Stream x direct mode error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn dmeif0(&self) -> DMEIF0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIF0R { bits }
-            }
-            #[doc = "Bit 0 - Stream x FIFO error interrupt flag (x=3..0)"]
-            #[inline]
-            pub fn feif0(&self) -> FEIF0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIF0R { bits }
-            }
-        }
-    }
-    #[doc = "high interrupt status register"]
-    pub struct HISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "high interrupt status register"]
-    pub mod hisr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::HISR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TCIF7R {
-            bits: bool,
-        }
-        impl TCIF7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIF7R {
-            bits: bool,
-        }
-        impl HTIF7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIF7R {
-            bits: bool,
-        }
-        impl TEIF7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIF7R {
-            bits: bool,
-        }
-        impl DMEIF7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FEIF7R {
-            bits: bool,
-        }
-        impl FEIF7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIF6R {
-            bits: bool,
-        }
-        impl TCIF6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIF6R {
-            bits: bool,
-        }
-        impl HTIF6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIF6R {
-            bits: bool,
-        }
-        impl TEIF6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIF6R {
-            bits: bool,
-        }
-        impl DMEIF6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FEIF6R {
-            bits: bool,
-        }
-        impl FEIF6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIF5R {
-            bits: bool,
-        }
-        impl TCIF5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIF5R {
-            bits: bool,
-        }
-        impl HTIF5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIF5R {
-            bits: bool,
-        }
-        impl TEIF5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIF5R {
-            bits: bool,
-        }
-        impl DMEIF5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FEIF5R {
-            bits: bool,
-        }
-        impl FEIF5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIF4R {
-            bits: bool,
-        }
-        impl TCIF4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIF4R {
-            bits: bool,
-        }
-        impl HTIF4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIF4R {
-            bits: bool,
-        }
-        impl TEIF4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIF4R {
-            bits: bool,
-        }
-        impl DMEIF4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FEIF4R {
-            bits: bool,
-        }
-        impl FEIF4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 27 - Stream x transfer complete interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn tcif7(&self) -> TCIF7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIF7R { bits }
-            }
-            #[doc = "Bit 26 - Stream x half transfer interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn htif7(&self) -> HTIF7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIF7R { bits }
-            }
-            #[doc = "Bit 25 - Stream x transfer error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn teif7(&self) -> TEIF7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIF7R { bits }
-            }
-            #[doc = "Bit 24 - Stream x direct mode error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn dmeif7(&self) -> DMEIF7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIF7R { bits }
-            }
-            #[doc = "Bit 22 - Stream x FIFO error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn feif7(&self) -> FEIF7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIF7R { bits }
-            }
-            #[doc = "Bit 21 - Stream x transfer complete interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn tcif6(&self) -> TCIF6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIF6R { bits }
-            }
-            #[doc = "Bit 20 - Stream x half transfer interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn htif6(&self) -> HTIF6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIF6R { bits }
-            }
-            #[doc = "Bit 19 - Stream x transfer error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn teif6(&self) -> TEIF6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIF6R { bits }
-            }
-            #[doc = "Bit 18 - Stream x direct mode error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn dmeif6(&self) -> DMEIF6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIF6R { bits }
-            }
-            #[doc = "Bit 16 - Stream x FIFO error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn feif6(&self) -> FEIF6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIF6R { bits }
-            }
-            #[doc = "Bit 11 - Stream x transfer complete interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn tcif5(&self) -> TCIF5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIF5R { bits }
-            }
-            #[doc = "Bit 10 - Stream x half transfer interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn htif5(&self) -> HTIF5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIF5R { bits }
-            }
-            #[doc = "Bit 9 - Stream x transfer error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn teif5(&self) -> TEIF5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIF5R { bits }
-            }
-            #[doc = "Bit 8 - Stream x direct mode error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn dmeif5(&self) -> DMEIF5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIF5R { bits }
-            }
-            #[doc = "Bit 6 - Stream x FIFO error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn feif5(&self) -> FEIF5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIF5R { bits }
-            }
-            #[doc = "Bit 5 - Stream x transfer complete interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn tcif4(&self) -> TCIF4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIF4R { bits }
-            }
-            #[doc = "Bit 4 - Stream x half transfer interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn htif4(&self) -> HTIF4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIF4R { bits }
-            }
-            #[doc = "Bit 3 - Stream x transfer error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn teif4(&self) -> TEIF4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIF4R { bits }
-            }
-            #[doc = "Bit 2 - Stream x direct mode error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn dmeif4(&self) -> DMEIF4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIF4R { bits }
-            }
-            #[doc = "Bit 0 - Stream x FIFO error interrupt flag (x=7..4)"]
-            #[inline]
-            pub fn feif4(&self) -> FEIF4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIF4R { bits }
-            }
-        }
-    }
-    #[doc = "low interrupt flag clear register"]
-    pub struct LIFCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "low interrupt flag clear register"]
-    pub mod lifcr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::LIFCR {
-            #[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" Proxy"]
-        pub struct _CTCIF3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCIF3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHTIF3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHTIF3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEIF3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEIF3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CDMEIF3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CDMEIF3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CFEIF3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CFEIF3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTCIF2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCIF2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHTIF2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHTIF2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEIF2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEIF2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CDMEIF2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CDMEIF2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CFEIF2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CFEIF2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTCIF1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCIF1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHTIF1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHTIF1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEIF1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEIF1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CDMEIF1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CDMEIF1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CFEIF1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CFEIF1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTCIF0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCIF0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHTIF0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHTIF0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEIF0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEIF0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CDMEIF0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CDMEIF0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CFEIF0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CFEIF0W<'a> {
-            #[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
-            }
-        }
-        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 27 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn ctcif3(&mut self) -> _CTCIF3W {
-                _CTCIF3W { w: self }
-            }
-            #[doc = "Bit 26 - Stream x clear half transfer interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn chtif3(&mut self) -> _CHTIF3W {
-                _CHTIF3W { w: self }
-            }
-            #[doc = "Bit 25 - Stream x clear transfer error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cteif3(&mut self) -> _CTEIF3W {
-                _CTEIF3W { w: self }
-            }
-            #[doc = "Bit 24 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cdmeif3(&mut self) -> _CDMEIF3W {
-                _CDMEIF3W { w: self }
-            }
-            #[doc = "Bit 22 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cfeif3(&mut self) -> _CFEIF3W {
-                _CFEIF3W { w: self }
-            }
-            #[doc = "Bit 21 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn ctcif2(&mut self) -> _CTCIF2W {
-                _CTCIF2W { w: self }
-            }
-            #[doc = "Bit 20 - Stream x clear half transfer interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn chtif2(&mut self) -> _CHTIF2W {
-                _CHTIF2W { w: self }
-            }
-            #[doc = "Bit 19 - Stream x clear transfer error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cteif2(&mut self) -> _CTEIF2W {
-                _CTEIF2W { w: self }
-            }
-            #[doc = "Bit 18 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cdmeif2(&mut self) -> _CDMEIF2W {
-                _CDMEIF2W { w: self }
-            }
-            #[doc = "Bit 16 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cfeif2(&mut self) -> _CFEIF2W {
-                _CFEIF2W { w: self }
-            }
-            #[doc = "Bit 11 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn ctcif1(&mut self) -> _CTCIF1W {
-                _CTCIF1W { w: self }
-            }
-            #[doc = "Bit 10 - Stream x clear half transfer interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn chtif1(&mut self) -> _CHTIF1W {
-                _CHTIF1W { w: self }
-            }
-            #[doc = "Bit 9 - Stream x clear transfer error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cteif1(&mut self) -> _CTEIF1W {
-                _CTEIF1W { w: self }
-            }
-            #[doc = "Bit 8 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cdmeif1(&mut self) -> _CDMEIF1W {
-                _CDMEIF1W { w: self }
-            }
-            #[doc = "Bit 6 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cfeif1(&mut self) -> _CFEIF1W {
-                _CFEIF1W { w: self }
-            }
-            #[doc = "Bit 5 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn ctcif0(&mut self) -> _CTCIF0W {
-                _CTCIF0W { w: self }
-            }
-            #[doc = "Bit 4 - Stream x clear half transfer interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn chtif0(&mut self) -> _CHTIF0W {
-                _CHTIF0W { w: self }
-            }
-            #[doc = "Bit 3 - Stream x clear transfer error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cteif0(&mut self) -> _CTEIF0W {
-                _CTEIF0W { w: self }
-            }
-            #[doc = "Bit 2 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cdmeif0(&mut self) -> _CDMEIF0W {
-                _CDMEIF0W { w: self }
-            }
-            #[doc = "Bit 0 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
-            #[inline]
-            pub fn cfeif0(&mut self) -> _CFEIF0W {
-                _CFEIF0W { w: self }
-            }
-        }
-    }
-    #[doc = "high interrupt flag clear register"]
-    pub struct HIFCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "high interrupt flag clear register"]
-    pub mod hifcr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::HIFCR {
-            #[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" Proxy"]
-        pub struct _CTCIF7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCIF7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHTIF7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHTIF7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEIF7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEIF7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CDMEIF7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CDMEIF7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CFEIF7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CFEIF7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTCIF6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCIF6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHTIF6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHTIF6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEIF6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEIF6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CDMEIF6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CDMEIF6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CFEIF6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CFEIF6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTCIF5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCIF5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHTIF5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHTIF5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEIF5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEIF5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CDMEIF5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CDMEIF5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CFEIF5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CFEIF5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTCIF4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCIF4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHTIF4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHTIF4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEIF4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEIF4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CDMEIF4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CDMEIF4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CFEIF4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CFEIF4W<'a> {
-            #[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
-            }
-        }
-        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 27 - Stream x clear transfer complete interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn ctcif7(&mut self) -> _CTCIF7W {
-                _CTCIF7W { w: self }
-            }
-            #[doc = "Bit 26 - Stream x clear half transfer interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn chtif7(&mut self) -> _CHTIF7W {
-                _CHTIF7W { w: self }
-            }
-            #[doc = "Bit 25 - Stream x clear transfer error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cteif7(&mut self) -> _CTEIF7W {
-                _CTEIF7W { w: self }
-            }
-            #[doc = "Bit 24 - Stream x clear direct mode error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cdmeif7(&mut self) -> _CDMEIF7W {
-                _CDMEIF7W { w: self }
-            }
-            #[doc = "Bit 22 - Stream x clear FIFO error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cfeif7(&mut self) -> _CFEIF7W {
-                _CFEIF7W { w: self }
-            }
-            #[doc = "Bit 21 - Stream x clear transfer complete interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn ctcif6(&mut self) -> _CTCIF6W {
-                _CTCIF6W { w: self }
-            }
-            #[doc = "Bit 20 - Stream x clear half transfer interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn chtif6(&mut self) -> _CHTIF6W {
-                _CHTIF6W { w: self }
-            }
-            #[doc = "Bit 19 - Stream x clear transfer error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cteif6(&mut self) -> _CTEIF6W {
-                _CTEIF6W { w: self }
-            }
-            #[doc = "Bit 18 - Stream x clear direct mode error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cdmeif6(&mut self) -> _CDMEIF6W {
-                _CDMEIF6W { w: self }
-            }
-            #[doc = "Bit 16 - Stream x clear FIFO error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cfeif6(&mut self) -> _CFEIF6W {
-                _CFEIF6W { w: self }
-            }
-            #[doc = "Bit 11 - Stream x clear transfer complete interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn ctcif5(&mut self) -> _CTCIF5W {
-                _CTCIF5W { w: self }
-            }
-            #[doc = "Bit 10 - Stream x clear half transfer interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn chtif5(&mut self) -> _CHTIF5W {
-                _CHTIF5W { w: self }
-            }
-            #[doc = "Bit 9 - Stream x clear transfer error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cteif5(&mut self) -> _CTEIF5W {
-                _CTEIF5W { w: self }
-            }
-            #[doc = "Bit 8 - Stream x clear direct mode error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cdmeif5(&mut self) -> _CDMEIF5W {
-                _CDMEIF5W { w: self }
-            }
-            #[doc = "Bit 6 - Stream x clear FIFO error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cfeif5(&mut self) -> _CFEIF5W {
-                _CFEIF5W { w: self }
-            }
-            #[doc = "Bit 5 - Stream x clear transfer complete interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn ctcif4(&mut self) -> _CTCIF4W {
-                _CTCIF4W { w: self }
-            }
-            #[doc = "Bit 4 - Stream x clear half transfer interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn chtif4(&mut self) -> _CHTIF4W {
-                _CHTIF4W { w: self }
-            }
-            #[doc = "Bit 3 - Stream x clear transfer error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cteif4(&mut self) -> _CTEIF4W {
-                _CTEIF4W { w: self }
-            }
-            #[doc = "Bit 2 - Stream x clear direct mode error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cdmeif4(&mut self) -> _CDMEIF4W {
-                _CDMEIF4W { w: self }
-            }
-            #[doc = "Bit 0 - Stream x clear FIFO error interrupt flag (x = 7..4)"]
-            #[inline]
-            pub fn cfeif4(&mut self) -> _CFEIF4W {
-                _CFEIF4W { w: self }
-            }
-        }
-    }
-    #[doc = "stream x configuration register"]
-    pub struct S0CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x configuration register"]
-    pub mod s0cr {
-        #[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::S0CR {
-            #[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 = r" Value of the field"]
-        pub struct CHSELR {
-            bits: u8,
-        }
-        impl CHSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MBURSTR {
-            bits: u8,
-        }
-        impl MBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PBURSTR {
-            bits: u8,
-        }
-        impl PBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CTR {
-            bits: bool,
-        }
-        impl CTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBMR {
-            bits: bool,
-        }
-        impl DBMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLR {
-            bits: u8,
-        }
-        impl PLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PINCOSR {
-            bits: bool,
-        }
-        impl PINCOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSIZER {
-            bits: u8,
-        }
-        impl MSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MINCR {
-            bits: bool,
-        }
-        impl MINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PINCR {
-            bits: bool,
-        }
-        impl PINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIRCR {
-            bits: bool,
-        }
-        impl CIRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: u8,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFCTRLR {
-            bits: bool,
-        }
-        impl PFCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIER {
-            bits: bool,
-        }
-        impl HTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIER {
-            bits: bool,
-        }
-        impl DMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CHSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 23;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PINCOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCOSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFCTRLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&self) -> CHSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHSELR { bits }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&self) -> MBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MBURSTR { bits }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&self) -> PBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PBURSTR { bits }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&self) -> CTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTR { bits }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&self) -> DBMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBMR { bits }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&self) -> PLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLR { bits }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&self) -> PINCOSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCOSR { bits }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&self) -> MSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MSIZER { bits }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&self) -> MINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MINCR { bits }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&self) -> PINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCR { bits }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&self) -> CIRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIRCR { bits }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&self) -> PFCTRLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PFCTRLR { bits }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&self) -> HTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIER { bits }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&self) -> DMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIER { bits }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&mut self) -> _CHSELW {
-                _CHSELW { w: self }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&mut self) -> _MBURSTW {
-                _MBURSTW { w: self }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&mut self) -> _PBURSTW {
-                _PBURSTW { w: self }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&mut self) -> _CTW {
-                _CTW { w: self }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&mut self) -> _DBMW {
-                _DBMW { w: self }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&mut self) -> _PLW {
-                _PLW { w: self }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&mut self) -> _PINCOSW {
-                _PINCOSW { w: self }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&mut self) -> _MSIZEW {
-                _MSIZEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&mut self) -> _MINCW {
-                _MINCW { w: self }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&mut self) -> _PINCW {
-                _PINCW { w: self }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&mut self) -> _CIRCW {
-                _CIRCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&mut self) -> _PFCTRLW {
-                _PFCTRLW { w: self }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&mut self) -> _HTIEW {
-                _HTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&mut self) -> _DMEIEW {
-                _DMEIEW { w: self }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x number of data register"]
-    pub struct S0NDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x number of data register"]
-    pub mod s0ndtr {
-        #[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::S0NDTR {
-            #[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 = r" Value of the field"]
-        pub struct NDTR {
-            bits: u16,
-        }
-        impl NDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&self) -> NDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NDTR { bits }
-            }
-        }
-        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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&mut self) -> _NDTW {
-                _NDTW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x peripheral address register"]
-    pub struct S0PAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x peripheral address register"]
-    pub mod s0par {
-        #[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::S0PAR {
-            #[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 = r" Value of the field"]
-        pub struct PAR {
-            bits: u32,
-        }
-        impl PAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&self) -> PAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PAR { bits }
-            }
-        }
-        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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&mut self) -> _PAW {
-                _PAW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub struct S0M0AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub mod s0m0ar {
-        #[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::S0M0AR {
-            #[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 = r" Value of the field"]
-        pub struct M0AR {
-            bits: u32,
-        }
-        impl M0AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M0AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M0AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&self) -> M0AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M0AR { bits }
-            }
-        }
-        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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&mut self) -> _M0AW {
-                _M0AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub struct S0M1AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub mod s0m1ar {
-        #[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::S0M1AR {
-            #[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 = r" Value of the field"]
-        pub struct M1AR {
-            bits: u32,
-        }
-        impl M1AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M1AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M1AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&self) -> M1AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M1AR { bits }
-            }
-        }
-        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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&mut self) -> _M1AW {
-                _M1AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x FIFO control register"]
-    pub struct S0FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x FIFO control register"]
-    pub mod s0fcr {
-        #[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::S0FCR {
-            #[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 = r" Value of the field"]
-        pub struct FEIER {
-            bits: bool,
-        }
-        impl FEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSR {
-            bits: u8,
-        }
-        impl FSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMDISR {
-            bits: bool,
-        }
-        impl DMDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&self) -> FEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIER { bits }
-            }
-            #[doc = "Bits 3:5 - FIFO status"]
-            #[inline]
-            pub fn fs(&self) -> FSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSR { bits }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&self) -> DMDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMDISR { bits }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x21 }
-            }
-            #[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 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&mut self) -> _FEIEW {
-                _FEIEW { w: self }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&mut self) -> _DMDISW {
-                _DMDISW { w: self }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x configuration register"]
-    pub struct S1CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x configuration register"]
-    pub mod s1cr {
-        #[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::S1CR {
-            #[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 = r" Value of the field"]
-        pub struct CHSELR {
-            bits: u8,
-        }
-        impl CHSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MBURSTR {
-            bits: u8,
-        }
-        impl MBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PBURSTR {
-            bits: u8,
-        }
-        impl PBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTR {
-            bits: bool,
-        }
-        impl CTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBMR {
-            bits: bool,
-        }
-        impl DBMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLR {
-            bits: u8,
-        }
-        impl PLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PINCOSR {
-            bits: bool,
-        }
-        impl PINCOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSIZER {
-            bits: u8,
-        }
-        impl MSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MINCR {
-            bits: bool,
-        }
-        impl MINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PINCR {
-            bits: bool,
-        }
-        impl PINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIRCR {
-            bits: bool,
-        }
-        impl CIRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: u8,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFCTRLR {
-            bits: bool,
-        }
-        impl PFCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIER {
-            bits: bool,
-        }
-        impl HTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIER {
-            bits: bool,
-        }
-        impl DMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CHSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 23;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PINCOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCOSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFCTRLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&self) -> CHSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHSELR { bits }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&self) -> MBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MBURSTR { bits }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&self) -> PBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PBURSTR { bits }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&self) -> CTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTR { bits }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&self) -> DBMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBMR { bits }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&self) -> PLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLR { bits }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&self) -> PINCOSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCOSR { bits }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&self) -> MSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MSIZER { bits }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&self) -> MINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MINCR { bits }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&self) -> PINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCR { bits }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&self) -> CIRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIRCR { bits }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&self) -> PFCTRLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PFCTRLR { bits }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&self) -> HTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIER { bits }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&self) -> DMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIER { bits }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&mut self) -> _CHSELW {
-                _CHSELW { w: self }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&mut self) -> _MBURSTW {
-                _MBURSTW { w: self }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&mut self) -> _PBURSTW {
-                _PBURSTW { w: self }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&mut self) -> _CTW {
-                _CTW { w: self }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&mut self) -> _DBMW {
-                _DBMW { w: self }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&mut self) -> _PLW {
-                _PLW { w: self }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&mut self) -> _PINCOSW {
-                _PINCOSW { w: self }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&mut self) -> _MSIZEW {
-                _MSIZEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&mut self) -> _MINCW {
-                _MINCW { w: self }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&mut self) -> _PINCW {
-                _PINCW { w: self }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&mut self) -> _CIRCW {
-                _CIRCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&mut self) -> _PFCTRLW {
-                _PFCTRLW { w: self }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&mut self) -> _HTIEW {
-                _HTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&mut self) -> _DMEIEW {
-                _DMEIEW { w: self }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x number of data register"]
-    pub struct S1NDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x number of data register"]
-    pub mod s1ndtr {
-        #[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::S1NDTR {
-            #[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 = r" Value of the field"]
-        pub struct NDTR {
-            bits: u16,
-        }
-        impl NDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&self) -> NDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NDTR { bits }
-            }
-        }
-        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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&mut self) -> _NDTW {
-                _NDTW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x peripheral address register"]
-    pub struct S1PAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x peripheral address register"]
-    pub mod s1par {
-        #[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::S1PAR {
-            #[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 = r" Value of the field"]
-        pub struct PAR {
-            bits: u32,
-        }
-        impl PAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&self) -> PAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PAR { bits }
-            }
-        }
-        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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&mut self) -> _PAW {
-                _PAW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub struct S1M0AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub mod s1m0ar {
-        #[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::S1M0AR {
-            #[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 = r" Value of the field"]
-        pub struct M0AR {
-            bits: u32,
-        }
-        impl M0AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M0AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M0AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&self) -> M0AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M0AR { bits }
-            }
-        }
-        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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&mut self) -> _M0AW {
-                _M0AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub struct S1M1AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub mod s1m1ar {
-        #[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::S1M1AR {
-            #[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 = r" Value of the field"]
-        pub struct M1AR {
-            bits: u32,
-        }
-        impl M1AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M1AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M1AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&self) -> M1AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M1AR { bits }
-            }
-        }
-        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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&mut self) -> _M1AW {
-                _M1AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x FIFO control register"]
-    pub struct S1FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x FIFO control register"]
-    pub mod s1fcr {
-        #[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::S1FCR {
-            #[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 = r" Value of the field"]
-        pub struct FEIER {
-            bits: bool,
-        }
-        impl FEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSR {
-            bits: u8,
-        }
-        impl FSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMDISR {
-            bits: bool,
-        }
-        impl DMDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&self) -> FEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIER { bits }
-            }
-            #[doc = "Bits 3:5 - FIFO status"]
-            #[inline]
-            pub fn fs(&self) -> FSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSR { bits }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&self) -> DMDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMDISR { bits }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x21 }
-            }
-            #[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 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&mut self) -> _FEIEW {
-                _FEIEW { w: self }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&mut self) -> _DMDISW {
-                _DMDISW { w: self }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x configuration register"]
-    pub struct S2CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x configuration register"]
-    pub mod s2cr {
-        #[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::S2CR {
-            #[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 = r" Value of the field"]
-        pub struct CHSELR {
-            bits: u8,
-        }
-        impl CHSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MBURSTR {
-            bits: u8,
-        }
-        impl MBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PBURSTR {
-            bits: u8,
-        }
-        impl PBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTR {
-            bits: bool,
-        }
-        impl CTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBMR {
-            bits: bool,
-        }
-        impl DBMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLR {
-            bits: u8,
-        }
-        impl PLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PINCOSR {
-            bits: bool,
-        }
-        impl PINCOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSIZER {
-            bits: u8,
-        }
-        impl MSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MINCR {
-            bits: bool,
-        }
-        impl MINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PINCR {
-            bits: bool,
-        }
-        impl PINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIRCR {
-            bits: bool,
-        }
-        impl CIRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: u8,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFCTRLR {
-            bits: bool,
-        }
-        impl PFCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIER {
-            bits: bool,
-        }
-        impl HTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIER {
-            bits: bool,
-        }
-        impl DMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CHSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 23;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PINCOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCOSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFCTRLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&self) -> CHSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHSELR { bits }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&self) -> MBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MBURSTR { bits }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&self) -> PBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PBURSTR { bits }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&self) -> CTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTR { bits }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&self) -> DBMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBMR { bits }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&self) -> PLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLR { bits }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&self) -> PINCOSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCOSR { bits }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&self) -> MSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MSIZER { bits }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&self) -> MINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MINCR { bits }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&self) -> PINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCR { bits }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&self) -> CIRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIRCR { bits }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&self) -> PFCTRLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PFCTRLR { bits }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&self) -> HTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIER { bits }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&self) -> DMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIER { bits }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&mut self) -> _CHSELW {
-                _CHSELW { w: self }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&mut self) -> _MBURSTW {
-                _MBURSTW { w: self }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&mut self) -> _PBURSTW {
-                _PBURSTW { w: self }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&mut self) -> _CTW {
-                _CTW { w: self }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&mut self) -> _DBMW {
-                _DBMW { w: self }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&mut self) -> _PLW {
-                _PLW { w: self }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&mut self) -> _PINCOSW {
-                _PINCOSW { w: self }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&mut self) -> _MSIZEW {
-                _MSIZEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&mut self) -> _MINCW {
-                _MINCW { w: self }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&mut self) -> _PINCW {
-                _PINCW { w: self }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&mut self) -> _CIRCW {
-                _CIRCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&mut self) -> _PFCTRLW {
-                _PFCTRLW { w: self }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&mut self) -> _HTIEW {
-                _HTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&mut self) -> _DMEIEW {
-                _DMEIEW { w: self }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x number of data register"]
-    pub struct S2NDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x number of data register"]
-    pub mod s2ndtr {
-        #[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::S2NDTR {
-            #[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 = r" Value of the field"]
-        pub struct NDTR {
-            bits: u16,
-        }
-        impl NDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&self) -> NDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NDTR { bits }
-            }
-        }
-        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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&mut self) -> _NDTW {
-                _NDTW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x peripheral address register"]
-    pub struct S2PAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x peripheral address register"]
-    pub mod s2par {
-        #[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::S2PAR {
-            #[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 = r" Value of the field"]
-        pub struct PAR {
-            bits: u32,
-        }
-        impl PAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&self) -> PAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PAR { bits }
-            }
-        }
-        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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&mut self) -> _PAW {
-                _PAW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub struct S2M0AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub mod s2m0ar {
-        #[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::S2M0AR {
-            #[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 = r" Value of the field"]
-        pub struct M0AR {
-            bits: u32,
-        }
-        impl M0AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M0AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M0AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&self) -> M0AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M0AR { bits }
-            }
-        }
-        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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&mut self) -> _M0AW {
-                _M0AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub struct S2M1AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub mod s2m1ar {
-        #[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::S2M1AR {
-            #[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 = r" Value of the field"]
-        pub struct M1AR {
-            bits: u32,
-        }
-        impl M1AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M1AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M1AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&self) -> M1AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M1AR { bits }
-            }
-        }
-        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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&mut self) -> _M1AW {
-                _M1AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x FIFO control register"]
-    pub struct S2FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x FIFO control register"]
-    pub mod s2fcr {
-        #[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::S2FCR {
-            #[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 = r" Value of the field"]
-        pub struct FEIER {
-            bits: bool,
-        }
-        impl FEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSR {
-            bits: u8,
-        }
-        impl FSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMDISR {
-            bits: bool,
-        }
-        impl DMDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&self) -> FEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIER { bits }
-            }
-            #[doc = "Bits 3:5 - FIFO status"]
-            #[inline]
-            pub fn fs(&self) -> FSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSR { bits }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&self) -> DMDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMDISR { bits }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x21 }
-            }
-            #[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 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&mut self) -> _FEIEW {
-                _FEIEW { w: self }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&mut self) -> _DMDISW {
-                _DMDISW { w: self }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x configuration register"]
-    pub struct S3CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x configuration register"]
-    pub mod s3cr {
-        #[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::S3CR {
-            #[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 = r" Value of the field"]
-        pub struct CHSELR {
-            bits: u8,
-        }
-        impl CHSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MBURSTR {
-            bits: u8,
-        }
-        impl MBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PBURSTR {
-            bits: u8,
-        }
-        impl PBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTR {
-            bits: bool,
-        }
-        impl CTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBMR {
-            bits: bool,
-        }
-        impl DBMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLR {
-            bits: u8,
-        }
-        impl PLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PINCOSR {
-            bits: bool,
-        }
-        impl PINCOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSIZER {
-            bits: u8,
-        }
-        impl MSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MINCR {
-            bits: bool,
-        }
-        impl MINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PINCR {
-            bits: bool,
-        }
-        impl PINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIRCR {
-            bits: bool,
-        }
-        impl CIRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: u8,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFCTRLR {
-            bits: bool,
-        }
-        impl PFCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIER {
-            bits: bool,
-        }
-        impl HTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIER {
-            bits: bool,
-        }
-        impl DMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CHSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 23;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PINCOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCOSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFCTRLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&self) -> CHSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHSELR { bits }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&self) -> MBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MBURSTR { bits }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&self) -> PBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PBURSTR { bits }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&self) -> CTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTR { bits }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&self) -> DBMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBMR { bits }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&self) -> PLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLR { bits }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&self) -> PINCOSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCOSR { bits }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&self) -> MSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MSIZER { bits }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&self) -> MINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MINCR { bits }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&self) -> PINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCR { bits }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&self) -> CIRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIRCR { bits }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&self) -> PFCTRLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PFCTRLR { bits }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&self) -> HTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIER { bits }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&self) -> DMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIER { bits }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&mut self) -> _CHSELW {
-                _CHSELW { w: self }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&mut self) -> _MBURSTW {
-                _MBURSTW { w: self }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&mut self) -> _PBURSTW {
-                _PBURSTW { w: self }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&mut self) -> _CTW {
-                _CTW { w: self }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&mut self) -> _DBMW {
-                _DBMW { w: self }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&mut self) -> _PLW {
-                _PLW { w: self }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&mut self) -> _PINCOSW {
-                _PINCOSW { w: self }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&mut self) -> _MSIZEW {
-                _MSIZEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&mut self) -> _MINCW {
-                _MINCW { w: self }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&mut self) -> _PINCW {
-                _PINCW { w: self }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&mut self) -> _CIRCW {
-                _CIRCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&mut self) -> _PFCTRLW {
-                _PFCTRLW { w: self }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&mut self) -> _HTIEW {
-                _HTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&mut self) -> _DMEIEW {
-                _DMEIEW { w: self }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x number of data register"]
-    pub struct S3NDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x number of data register"]
-    pub mod s3ndtr {
-        #[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::S3NDTR {
-            #[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 = r" Value of the field"]
-        pub struct NDTR {
-            bits: u16,
-        }
-        impl NDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&self) -> NDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NDTR { bits }
-            }
-        }
-        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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&mut self) -> _NDTW {
-                _NDTW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x peripheral address register"]
-    pub struct S3PAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x peripheral address register"]
-    pub mod s3par {
-        #[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::S3PAR {
-            #[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 = r" Value of the field"]
-        pub struct PAR {
-            bits: u32,
-        }
-        impl PAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&self) -> PAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PAR { bits }
-            }
-        }
-        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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&mut self) -> _PAW {
-                _PAW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub struct S3M0AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub mod s3m0ar {
-        #[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::S3M0AR {
-            #[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 = r" Value of the field"]
-        pub struct M0AR {
-            bits: u32,
-        }
-        impl M0AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M0AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M0AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&self) -> M0AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M0AR { bits }
-            }
-        }
-        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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&mut self) -> _M0AW {
-                _M0AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub struct S3M1AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub mod s3m1ar {
-        #[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::S3M1AR {
-            #[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 = r" Value of the field"]
-        pub struct M1AR {
-            bits: u32,
-        }
-        impl M1AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M1AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M1AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&self) -> M1AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M1AR { bits }
-            }
-        }
-        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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&mut self) -> _M1AW {
-                _M1AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x FIFO control register"]
-    pub struct S3FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x FIFO control register"]
-    pub mod s3fcr {
-        #[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::S3FCR {
-            #[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 = r" Value of the field"]
-        pub struct FEIER {
-            bits: bool,
-        }
-        impl FEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSR {
-            bits: u8,
-        }
-        impl FSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMDISR {
-            bits: bool,
-        }
-        impl DMDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&self) -> FEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIER { bits }
-            }
-            #[doc = "Bits 3:5 - FIFO status"]
-            #[inline]
-            pub fn fs(&self) -> FSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSR { bits }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&self) -> DMDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMDISR { bits }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x21 }
-            }
-            #[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 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&mut self) -> _FEIEW {
-                _FEIEW { w: self }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&mut self) -> _DMDISW {
-                _DMDISW { w: self }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x configuration register"]
-    pub struct S4CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x configuration register"]
-    pub mod s4cr {
-        #[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::S4CR {
-            #[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 = r" Value of the field"]
-        pub struct CHSELR {
-            bits: u8,
-        }
-        impl CHSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MBURSTR {
-            bits: u8,
-        }
-        impl MBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PBURSTR {
-            bits: u8,
-        }
-        impl PBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTR {
-            bits: bool,
-        }
-        impl CTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBMR {
-            bits: bool,
-        }
-        impl DBMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLR {
-            bits: u8,
-        }
-        impl PLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PINCOSR {
-            bits: bool,
-        }
-        impl PINCOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSIZER {
-            bits: u8,
-        }
-        impl MSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MINCR {
-            bits: bool,
-        }
-        impl MINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PINCR {
-            bits: bool,
-        }
-        impl PINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIRCR {
-            bits: bool,
-        }
-        impl CIRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: u8,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFCTRLR {
-            bits: bool,
-        }
-        impl PFCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIER {
-            bits: bool,
-        }
-        impl HTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIER {
-            bits: bool,
-        }
-        impl DMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CHSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 23;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PINCOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCOSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFCTRLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&self) -> CHSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHSELR { bits }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&self) -> MBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MBURSTR { bits }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&self) -> PBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PBURSTR { bits }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&self) -> CTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTR { bits }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&self) -> DBMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBMR { bits }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&self) -> PLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLR { bits }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&self) -> PINCOSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCOSR { bits }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&self) -> MSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MSIZER { bits }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&self) -> MINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MINCR { bits }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&self) -> PINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCR { bits }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&self) -> CIRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIRCR { bits }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&self) -> PFCTRLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PFCTRLR { bits }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&self) -> HTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIER { bits }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&self) -> DMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIER { bits }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&mut self) -> _CHSELW {
-                _CHSELW { w: self }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&mut self) -> _MBURSTW {
-                _MBURSTW { w: self }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&mut self) -> _PBURSTW {
-                _PBURSTW { w: self }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&mut self) -> _CTW {
-                _CTW { w: self }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&mut self) -> _DBMW {
-                _DBMW { w: self }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&mut self) -> _PLW {
-                _PLW { w: self }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&mut self) -> _PINCOSW {
-                _PINCOSW { w: self }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&mut self) -> _MSIZEW {
-                _MSIZEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&mut self) -> _MINCW {
-                _MINCW { w: self }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&mut self) -> _PINCW {
-                _PINCW { w: self }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&mut self) -> _CIRCW {
-                _CIRCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&mut self) -> _PFCTRLW {
-                _PFCTRLW { w: self }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&mut self) -> _HTIEW {
-                _HTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&mut self) -> _DMEIEW {
-                _DMEIEW { w: self }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x number of data register"]
-    pub struct S4NDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x number of data register"]
-    pub mod s4ndtr {
-        #[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::S4NDTR {
-            #[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 = r" Value of the field"]
-        pub struct NDTR {
-            bits: u16,
-        }
-        impl NDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&self) -> NDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NDTR { bits }
-            }
-        }
-        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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&mut self) -> _NDTW {
-                _NDTW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x peripheral address register"]
-    pub struct S4PAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x peripheral address register"]
-    pub mod s4par {
-        #[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::S4PAR {
-            #[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 = r" Value of the field"]
-        pub struct PAR {
-            bits: u32,
-        }
-        impl PAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&self) -> PAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PAR { bits }
-            }
-        }
-        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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&mut self) -> _PAW {
-                _PAW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub struct S4M0AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub mod s4m0ar {
-        #[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::S4M0AR {
-            #[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 = r" Value of the field"]
-        pub struct M0AR {
-            bits: u32,
-        }
-        impl M0AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M0AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M0AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&self) -> M0AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M0AR { bits }
-            }
-        }
-        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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&mut self) -> _M0AW {
-                _M0AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub struct S4M1AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub mod s4m1ar {
-        #[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::S4M1AR {
-            #[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 = r" Value of the field"]
-        pub struct M1AR {
-            bits: u32,
-        }
-        impl M1AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M1AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M1AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&self) -> M1AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M1AR { bits }
-            }
-        }
-        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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&mut self) -> _M1AW {
-                _M1AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x FIFO control register"]
-    pub struct S4FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x FIFO control register"]
-    pub mod s4fcr {
-        #[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::S4FCR {
-            #[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 = r" Value of the field"]
-        pub struct FEIER {
-            bits: bool,
-        }
-        impl FEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSR {
-            bits: u8,
-        }
-        impl FSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMDISR {
-            bits: bool,
-        }
-        impl DMDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&self) -> FEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIER { bits }
-            }
-            #[doc = "Bits 3:5 - FIFO status"]
-            #[inline]
-            pub fn fs(&self) -> FSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSR { bits }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&self) -> DMDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMDISR { bits }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x21 }
-            }
-            #[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 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&mut self) -> _FEIEW {
-                _FEIEW { w: self }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&mut self) -> _DMDISW {
-                _DMDISW { w: self }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x configuration register"]
-    pub struct S5CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x configuration register"]
-    pub mod s5cr {
-        #[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::S5CR {
-            #[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 = r" Value of the field"]
-        pub struct CHSELR {
-            bits: u8,
-        }
-        impl CHSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MBURSTR {
-            bits: u8,
-        }
-        impl MBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PBURSTR {
-            bits: u8,
-        }
-        impl PBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTR {
-            bits: bool,
-        }
-        impl CTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBMR {
-            bits: bool,
-        }
-        impl DBMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLR {
-            bits: u8,
-        }
-        impl PLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PINCOSR {
-            bits: bool,
-        }
-        impl PINCOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSIZER {
-            bits: u8,
-        }
-        impl MSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MINCR {
-            bits: bool,
-        }
-        impl MINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PINCR {
-            bits: bool,
-        }
-        impl PINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIRCR {
-            bits: bool,
-        }
-        impl CIRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: u8,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFCTRLR {
-            bits: bool,
-        }
-        impl PFCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIER {
-            bits: bool,
-        }
-        impl HTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIER {
-            bits: bool,
-        }
-        impl DMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CHSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 23;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PINCOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCOSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFCTRLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&self) -> CHSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHSELR { bits }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&self) -> MBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MBURSTR { bits }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&self) -> PBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PBURSTR { bits }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&self) -> CTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTR { bits }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&self) -> DBMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBMR { bits }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&self) -> PLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLR { bits }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&self) -> PINCOSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCOSR { bits }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&self) -> MSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MSIZER { bits }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&self) -> MINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MINCR { bits }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&self) -> PINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCR { bits }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&self) -> CIRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIRCR { bits }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&self) -> PFCTRLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PFCTRLR { bits }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&self) -> HTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIER { bits }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&self) -> DMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIER { bits }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&mut self) -> _CHSELW {
-                _CHSELW { w: self }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&mut self) -> _MBURSTW {
-                _MBURSTW { w: self }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&mut self) -> _PBURSTW {
-                _PBURSTW { w: self }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&mut self) -> _CTW {
-                _CTW { w: self }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&mut self) -> _DBMW {
-                _DBMW { w: self }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&mut self) -> _PLW {
-                _PLW { w: self }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&mut self) -> _PINCOSW {
-                _PINCOSW { w: self }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&mut self) -> _MSIZEW {
-                _MSIZEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&mut self) -> _MINCW {
-                _MINCW { w: self }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&mut self) -> _PINCW {
-                _PINCW { w: self }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&mut self) -> _CIRCW {
-                _CIRCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&mut self) -> _PFCTRLW {
-                _PFCTRLW { w: self }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&mut self) -> _HTIEW {
-                _HTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&mut self) -> _DMEIEW {
-                _DMEIEW { w: self }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x number of data register"]
-    pub struct S5NDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x number of data register"]
-    pub mod s5ndtr {
-        #[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::S5NDTR {
-            #[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 = r" Value of the field"]
-        pub struct NDTR {
-            bits: u16,
-        }
-        impl NDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&self) -> NDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NDTR { bits }
-            }
-        }
-        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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&mut self) -> _NDTW {
-                _NDTW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x peripheral address register"]
-    pub struct S5PAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x peripheral address register"]
-    pub mod s5par {
-        #[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::S5PAR {
-            #[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 = r" Value of the field"]
-        pub struct PAR {
-            bits: u32,
-        }
-        impl PAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&self) -> PAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PAR { bits }
-            }
-        }
-        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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&mut self) -> _PAW {
-                _PAW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub struct S5M0AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub mod s5m0ar {
-        #[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::S5M0AR {
-            #[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 = r" Value of the field"]
-        pub struct M0AR {
-            bits: u32,
-        }
-        impl M0AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M0AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M0AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&self) -> M0AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M0AR { bits }
-            }
-        }
-        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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&mut self) -> _M0AW {
-                _M0AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub struct S5M1AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub mod s5m1ar {
-        #[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::S5M1AR {
-            #[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 = r" Value of the field"]
-        pub struct M1AR {
-            bits: u32,
-        }
-        impl M1AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M1AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M1AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&self) -> M1AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M1AR { bits }
-            }
-        }
-        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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&mut self) -> _M1AW {
-                _M1AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x FIFO control register"]
-    pub struct S5FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x FIFO control register"]
-    pub mod s5fcr {
-        #[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::S5FCR {
-            #[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 = r" Value of the field"]
-        pub struct FEIER {
-            bits: bool,
-        }
-        impl FEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSR {
-            bits: u8,
-        }
-        impl FSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMDISR {
-            bits: bool,
-        }
-        impl DMDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&self) -> FEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIER { bits }
-            }
-            #[doc = "Bits 3:5 - FIFO status"]
-            #[inline]
-            pub fn fs(&self) -> FSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSR { bits }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&self) -> DMDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMDISR { bits }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x21 }
-            }
-            #[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 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&mut self) -> _FEIEW {
-                _FEIEW { w: self }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&mut self) -> _DMDISW {
-                _DMDISW { w: self }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x configuration register"]
-    pub struct S6CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x configuration register"]
-    pub mod s6cr {
-        #[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::S6CR {
-            #[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 = r" Value of the field"]
-        pub struct CHSELR {
-            bits: u8,
-        }
-        impl CHSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MBURSTR {
-            bits: u8,
-        }
-        impl MBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PBURSTR {
-            bits: u8,
-        }
-        impl PBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTR {
-            bits: bool,
-        }
-        impl CTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBMR {
-            bits: bool,
-        }
-        impl DBMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLR {
-            bits: u8,
-        }
-        impl PLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PINCOSR {
-            bits: bool,
-        }
-        impl PINCOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSIZER {
-            bits: u8,
-        }
-        impl MSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MINCR {
-            bits: bool,
-        }
-        impl MINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PINCR {
-            bits: bool,
-        }
-        impl PINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIRCR {
-            bits: bool,
-        }
-        impl CIRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: u8,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFCTRLR {
-            bits: bool,
-        }
-        impl PFCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIER {
-            bits: bool,
-        }
-        impl HTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIER {
-            bits: bool,
-        }
-        impl DMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CHSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 23;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PINCOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCOSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFCTRLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&self) -> CHSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHSELR { bits }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&self) -> MBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MBURSTR { bits }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&self) -> PBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PBURSTR { bits }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&self) -> CTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTR { bits }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&self) -> DBMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBMR { bits }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&self) -> PLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLR { bits }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&self) -> PINCOSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCOSR { bits }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&self) -> MSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MSIZER { bits }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&self) -> MINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MINCR { bits }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&self) -> PINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCR { bits }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&self) -> CIRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIRCR { bits }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&self) -> PFCTRLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PFCTRLR { bits }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&self) -> HTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIER { bits }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&self) -> DMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIER { bits }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&mut self) -> _CHSELW {
-                _CHSELW { w: self }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&mut self) -> _MBURSTW {
-                _MBURSTW { w: self }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&mut self) -> _PBURSTW {
-                _PBURSTW { w: self }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&mut self) -> _CTW {
-                _CTW { w: self }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&mut self) -> _DBMW {
-                _DBMW { w: self }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&mut self) -> _PLW {
-                _PLW { w: self }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&mut self) -> _PINCOSW {
-                _PINCOSW { w: self }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&mut self) -> _MSIZEW {
-                _MSIZEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&mut self) -> _MINCW {
-                _MINCW { w: self }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&mut self) -> _PINCW {
-                _PINCW { w: self }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&mut self) -> _CIRCW {
-                _CIRCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&mut self) -> _PFCTRLW {
-                _PFCTRLW { w: self }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&mut self) -> _HTIEW {
-                _HTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&mut self) -> _DMEIEW {
-                _DMEIEW { w: self }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x number of data register"]
-    pub struct S6NDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x number of data register"]
-    pub mod s6ndtr {
-        #[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::S6NDTR {
-            #[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 = r" Value of the field"]
-        pub struct NDTR {
-            bits: u16,
-        }
-        impl NDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&self) -> NDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NDTR { bits }
-            }
-        }
-        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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&mut self) -> _NDTW {
-                _NDTW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x peripheral address register"]
-    pub struct S6PAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x peripheral address register"]
-    pub mod s6par {
-        #[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::S6PAR {
-            #[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 = r" Value of the field"]
-        pub struct PAR {
-            bits: u32,
-        }
-        impl PAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&self) -> PAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PAR { bits }
-            }
-        }
-        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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&mut self) -> _PAW {
-                _PAW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub struct S6M0AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub mod s6m0ar {
-        #[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::S6M0AR {
-            #[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 = r" Value of the field"]
-        pub struct M0AR {
-            bits: u32,
-        }
-        impl M0AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M0AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M0AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&self) -> M0AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M0AR { bits }
-            }
-        }
-        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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&mut self) -> _M0AW {
-                _M0AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub struct S6M1AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub mod s6m1ar {
-        #[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::S6M1AR {
-            #[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 = r" Value of the field"]
-        pub struct M1AR {
-            bits: u32,
-        }
-        impl M1AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M1AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M1AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&self) -> M1AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M1AR { bits }
-            }
-        }
-        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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&mut self) -> _M1AW {
-                _M1AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x FIFO control register"]
-    pub struct S6FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x FIFO control register"]
-    pub mod s6fcr {
-        #[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::S6FCR {
-            #[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 = r" Value of the field"]
-        pub struct FEIER {
-            bits: bool,
-        }
-        impl FEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSR {
-            bits: u8,
-        }
-        impl FSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMDISR {
-            bits: bool,
-        }
-        impl DMDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&self) -> FEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIER { bits }
-            }
-            #[doc = "Bits 3:5 - FIFO status"]
-            #[inline]
-            pub fn fs(&self) -> FSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSR { bits }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&self) -> DMDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMDISR { bits }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x21 }
-            }
-            #[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 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&mut self) -> _FEIEW {
-                _FEIEW { w: self }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&mut self) -> _DMDISW {
-                _DMDISW { w: self }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x configuration register"]
-    pub struct S7CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x configuration register"]
-    pub mod s7cr {
-        #[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::S7CR {
-            #[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 = r" Value of the field"]
-        pub struct CHSELR {
-            bits: u8,
-        }
-        impl CHSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MBURSTR {
-            bits: u8,
-        }
-        impl MBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PBURSTR {
-            bits: u8,
-        }
-        impl PBURSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTR {
-            bits: bool,
-        }
-        impl CTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBMR {
-            bits: bool,
-        }
-        impl DBMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLR {
-            bits: u8,
-        }
-        impl PLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PINCOSR {
-            bits: bool,
-        }
-        impl PINCOSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSIZER {
-            bits: u8,
-        }
-        impl MSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSIZER {
-            bits: u8,
-        }
-        impl PSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MINCR {
-            bits: bool,
-        }
-        impl MINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PINCR {
-            bits: bool,
-        }
-        impl PINCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIRCR {
-            bits: bool,
-        }
-        impl CIRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: u8,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFCTRLR {
-            bits: bool,
-        }
-        impl PFCTRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HTIER {
-            bits: bool,
-        }
-        impl HTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMEIER {
-            bits: bool,
-        }
-        impl DMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CHSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 25;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 23;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PBURSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBURSTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PINCOSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCOSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PINCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PINCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DIRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFCTRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFCTRLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&self) -> CHSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHSELR { bits }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&self) -> MBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MBURSTR { bits }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&self) -> PBURSTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PBURSTR { bits }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&self) -> CTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTR { bits }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&self) -> DBMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBMR { bits }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&self) -> PLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLR { bits }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&self) -> PINCOSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCOSR { bits }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&self) -> MSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MSIZER { bits }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&self) -> PSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSIZER { bits }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&self) -> MINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MINCR { bits }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&self) -> PINCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PINCR { bits }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&self) -> CIRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIRCR { bits }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&self) -> PFCTRLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PFCTRLR { bits }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&self) -> HTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HTIER { bits }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&self) -> DMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMEIER { bits }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 25:27 - Channel selection"]
-            #[inline]
-            pub fn chsel(&mut self) -> _CHSELW {
-                _CHSELW { w: self }
-            }
-            #[doc = "Bits 23:24 - Memory burst transfer configuration"]
-            #[inline]
-            pub fn mburst(&mut self) -> _MBURSTW {
-                _MBURSTW { w: self }
-            }
-            #[doc = "Bits 21:22 - Peripheral burst transfer configuration"]
-            #[inline]
-            pub fn pburst(&mut self) -> _PBURSTW {
-                _PBURSTW { w: self }
-            }
-            #[doc = "Bit 20 - ACK"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 19 - Current target (only in double buffer mode)"]
-            #[inline]
-            pub fn ct(&mut self) -> _CTW {
-                _CTW { w: self }
-            }
-            #[doc = "Bit 18 - Double buffer mode"]
-            #[inline]
-            pub fn dbm(&mut self) -> _DBMW {
-                _DBMW { w: self }
-            }
-            #[doc = "Bits 16:17 - Priority level"]
-            #[inline]
-            pub fn pl(&mut self) -> _PLW {
-                _PLW { w: self }
-            }
-            #[doc = "Bit 15 - Peripheral increment offset size"]
-            #[inline]
-            pub fn pincos(&mut self) -> _PINCOSW {
-                _PINCOSW { w: self }
-            }
-            #[doc = "Bits 13:14 - Memory data size"]
-            #[inline]
-            pub fn msize(&mut self) -> _MSIZEW {
-                _MSIZEW { w: self }
-            }
-            #[doc = "Bits 11:12 - Peripheral data size"]
-            #[inline]
-            pub fn psize(&mut self) -> _PSIZEW {
-                _PSIZEW { w: self }
-            }
-            #[doc = "Bit 10 - Memory increment mode"]
-            #[inline]
-            pub fn minc(&mut self) -> _MINCW {
-                _MINCW { w: self }
-            }
-            #[doc = "Bit 9 - Peripheral increment mode"]
-            #[inline]
-            pub fn pinc(&mut self) -> _PINCW {
-                _PINCW { w: self }
-            }
-            #[doc = "Bit 8 - Circular mode"]
-            #[inline]
-            pub fn circ(&mut self) -> _CIRCW {
-                _CIRCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Data transfer direction"]
-            #[inline]
-            pub fn dir(&mut self) -> _DIRW {
-                _DIRW { w: self }
-            }
-            #[doc = "Bit 5 - Peripheral flow controller"]
-            #[inline]
-            pub fn pfctrl(&mut self) -> _PFCTRLW {
-                _PFCTRLW { w: self }
-            }
-            #[doc = "Bit 4 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 3 - Half transfer interrupt enable"]
-            #[inline]
-            pub fn htie(&mut self) -> _HTIEW {
-                _HTIEW { w: self }
-            }
-            #[doc = "Bit 2 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bit 1 - Direct mode error interrupt enable"]
-            #[inline]
-            pub fn dmeie(&mut self) -> _DMEIEW {
-                _DMEIEW { w: self }
-            }
-            #[doc = "Bit 0 - Stream enable / flag stream ready when read low"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x number of data register"]
-    pub struct S7NDTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x number of data register"]
-    pub mod s7ndtr {
-        #[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::S7NDTR {
-            #[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 = r" Value of the field"]
-        pub struct NDTR {
-            bits: u16,
-        }
-        impl NDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&self) -> NDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NDTR { bits }
-            }
-        }
-        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 0:15 - Number of data items to transfer"]
-            #[inline]
-            pub fn ndt(&mut self) -> _NDTW {
-                _NDTW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x peripheral address register"]
-    pub struct S7PAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x peripheral address register"]
-    pub mod s7par {
-        #[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::S7PAR {
-            #[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 = r" Value of the field"]
-        pub struct PAR {
-            bits: u32,
-        }
-        impl PAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&self) -> PAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PAR { bits }
-            }
-        }
-        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 0:31 - Peripheral address"]
-            #[inline]
-            pub fn pa(&mut self) -> _PAW {
-                _PAW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub struct S7M0AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 0 address register"]
-    pub mod s7m0ar {
-        #[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::S7M0AR {
-            #[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 = r" Value of the field"]
-        pub struct M0AR {
-            bits: u32,
-        }
-        impl M0AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M0AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M0AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&self) -> M0AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M0AR { bits }
-            }
-        }
-        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 0:31 - Memory 0 address"]
-            #[inline]
-            pub fn m0a(&mut self) -> _M0AW {
-                _M0AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub struct S7M1AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x memory 1 address register"]
-    pub mod s7m1ar {
-        #[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::S7M1AR {
-            #[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 = r" Value of the field"]
-        pub struct M1AR {
-            bits: u32,
-        }
-        impl M1AR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _M1AW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _M1AW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&self) -> M1AR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                M1AR { bits }
-            }
-        }
-        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 0:31 - Memory 1 address (used in case of Double buffer mode)"]
-            #[inline]
-            pub fn m1a(&mut self) -> _M1AW {
-                _M1AW { w: self }
-            }
-        }
-    }
-    #[doc = "stream x FIFO control register"]
-    pub struct S7FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "stream x FIFO control register"]
-    pub mod s7fcr {
-        #[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::S7FCR {
-            #[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 = r" Value of the field"]
-        pub struct FEIER {
-            bits: bool,
-        }
-        impl FEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSR {
-            bits: u8,
-        }
-        impl FSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMDISR {
-            bits: bool,
-        }
-        impl DMDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&self) -> FEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEIER { bits }
-            }
-            #[doc = "Bits 3:5 - FIFO status"]
-            #[inline]
-            pub fn fs(&self) -> FSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSR { bits }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&self) -> DMDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMDISR { bits }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x21 }
-            }
-            #[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 7 - FIFO error interrupt enable"]
-            #[inline]
-            pub fn feie(&mut self) -> _FEIEW {
-                _FEIEW { w: self }
-            }
-            #[doc = "Bit 2 - Direct mode disable"]
-            #[inline]
-            pub fn dmdis(&mut self) -> _DMDISW {
-                _DMDISW { w: self }
-            }
-            #[doc = "Bits 0:1 - FIFO threshold selection"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
-    }
-}
-#[doc = "DMA1"]
-pub struct DMA1 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for DMA1 {}
-impl DMA1 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const dma2::RegisterBlock {
-        0x4002_6000 as *const _
-    }
-}
-impl Deref for DMA1 {
-    type Target = dma2::RegisterBlock;
-    fn deref(&self) -> &dma2::RegisterBlock {
-        unsafe { &*DMA1::ptr() }
-    }
-}
-#[doc = "General-purpose I/Os"]
-pub struct GPIOH {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for GPIOH {}
-impl GPIOH {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const gpioh::RegisterBlock {
-        0x4002_1c00 as *const _
-    }
-}
-impl Deref for GPIOH {
-    type Target = gpioh::RegisterBlock;
-    fn deref(&self) -> &gpioh::RegisterBlock {
-        unsafe { &*GPIOH::ptr() }
-    }
-}
-#[doc = "General-purpose I/Os"]
-pub mod gpioh {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - GPIO port mode register"]
-        pub moder: MODER,
-        #[doc = "0x04 - GPIO port output type register"]
-        pub otyper: OTYPER,
-        #[doc = "0x08 - GPIO port output speed register"]
-        pub ospeedr: OSPEEDR,
-        #[doc = "0x0c - GPIO port pull-up/pull-down register"]
-        pub pupdr: PUPDR,
-        #[doc = "0x10 - GPIO port input data register"]
-        pub idr: IDR,
-        #[doc = "0x14 - GPIO port output data register"]
-        pub odr: ODR,
-        #[doc = "0x18 - GPIO port bit set/reset register"]
-        pub bsrr: BSRR,
-        #[doc = "0x1c - GPIO port configuration lock register"]
-        pub lckr: LCKR,
-        #[doc = "0x20 - GPIO alternate function low register"]
-        pub afrl: AFRL,
-        #[doc = "0x24 - GPIO alternate function high register"]
-        pub afrh: AFRH,
-    }
-    #[doc = "GPIO port mode register"]
-    pub struct MODER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port mode register"]
-    pub mod moder {
-        #[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::MODER {
-            #[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 = r" Value of the field"]
-        pub struct MODER15R {
-            bits: u8,
-        }
-        impl MODER15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER14R {
-            bits: u8,
-        }
-        impl MODER14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER13R {
-            bits: u8,
-        }
-        impl MODER13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER12R {
-            bits: u8,
-        }
-        impl MODER12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER11R {
-            bits: u8,
-        }
-        impl MODER11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER10R {
-            bits: u8,
-        }
-        impl MODER10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER9R {
-            bits: u8,
-        }
-        impl MODER9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER8R {
-            bits: u8,
-        }
-        impl MODER8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER7R {
-            bits: u8,
-        }
-        impl MODER7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER6R {
-            bits: u8,
-        }
-        impl MODER6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER5R {
-            bits: u8,
-        }
-        impl MODER5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER4R {
-            bits: u8,
-        }
-        impl MODER4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER3R {
-            bits: u8,
-        }
-        impl MODER3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER2R {
-            bits: u8,
-        }
-        impl MODER2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER1R {
-            bits: u8,
-        }
-        impl MODER1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER0R {
-            bits: u8,
-        }
-        impl MODER0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder15(&self) -> MODER15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder14(&self) -> MODER14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder13(&self) -> MODER13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder12(&self) -> MODER12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder11(&self) -> MODER11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder10(&self) -> MODER10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder9(&self) -> MODER9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder8(&self) -> MODER8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder7(&self) -> MODER7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder6(&self) -> MODER6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder5(&self) -> MODER5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder4(&self) -> MODER4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder3(&self) -> MODER3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder2(&self) -> MODER2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder1(&self) -> MODER1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder0(&self) -> MODER0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER0R { bits }
-            }
-        }
-        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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder15(&mut self) -> _MODER15W {
-                _MODER15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder14(&mut self) -> _MODER14W {
-                _MODER14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder13(&mut self) -> _MODER13W {
-                _MODER13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder12(&mut self) -> _MODER12W {
-                _MODER12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder11(&mut self) -> _MODER11W {
-                _MODER11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder10(&mut self) -> _MODER10W {
-                _MODER10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder9(&mut self) -> _MODER9W {
-                _MODER9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder8(&mut self) -> _MODER8W {
-                _MODER8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder7(&mut self) -> _MODER7W {
-                _MODER7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder6(&mut self) -> _MODER6W {
-                _MODER6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder5(&mut self) -> _MODER5W {
-                _MODER5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder4(&mut self) -> _MODER4W {
-                _MODER4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder3(&mut self) -> _MODER3W {
-                _MODER3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder2(&mut self) -> _MODER2W {
-                _MODER2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder1(&mut self) -> _MODER1W {
-                _MODER1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder0(&mut self) -> _MODER0W {
-                _MODER0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port output type register"]
-    pub struct OTYPER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output type register"]
-    pub mod otyper {
-        #[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::OTYPER {
-            #[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 = r" Value of the field"]
-        pub struct OT15R {
-            bits: bool,
-        }
-        impl OT15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT14R {
-            bits: bool,
-        }
-        impl OT14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT13R {
-            bits: bool,
-        }
-        impl OT13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT12R {
-            bits: bool,
-        }
-        impl OT12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT11R {
-            bits: bool,
-        }
-        impl OT11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT10R {
-            bits: bool,
-        }
-        impl OT10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT9R {
-            bits: bool,
-        }
-        impl OT9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT8R {
-            bits: bool,
-        }
-        impl OT8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT7R {
-            bits: bool,
-        }
-        impl OT7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT6R {
-            bits: bool,
-        }
-        impl OT6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT5R {
-            bits: bool,
-        }
-        impl OT5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT4R {
-            bits: bool,
-        }
-        impl OT4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT3R {
-            bits: bool,
-        }
-        impl OT3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT2R {
-            bits: bool,
-        }
-        impl OT2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT1R {
-            bits: bool,
-        }
-        impl OT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT0R {
-            bits: bool,
-        }
-        impl OT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OT15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot15(&self) -> OT15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT15R { bits }
-            }
-            #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot14(&self) -> OT14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT14R { bits }
-            }
-            #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot13(&self) -> OT13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT13R { bits }
-            }
-            #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot12(&self) -> OT12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT12R { bits }
-            }
-            #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot11(&self) -> OT11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT11R { bits }
-            }
-            #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot10(&self) -> OT10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT10R { bits }
-            }
-            #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot9(&self) -> OT9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT9R { bits }
-            }
-            #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot8(&self) -> OT8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT8R { bits }
-            }
-            #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot7(&self) -> OT7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT7R { bits }
-            }
-            #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot6(&self) -> OT6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT6R { bits }
-            }
-            #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot5(&self) -> OT5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT5R { bits }
-            }
-            #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot4(&self) -> OT4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT4R { bits }
-            }
-            #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot3(&self) -> OT3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT3R { bits }
-            }
-            #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot2(&self) -> OT2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT2R { bits }
-            }
-            #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot1(&self) -> OT1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT1R { bits }
-            }
-            #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot0(&self) -> OT0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT0R { bits }
-            }
-        }
-        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 15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot15(&mut self) -> _OT15W {
-                _OT15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot14(&mut self) -> _OT14W {
-                _OT14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot13(&mut self) -> _OT13W {
-                _OT13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot12(&mut self) -> _OT12W {
-                _OT12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot11(&mut self) -> _OT11W {
-                _OT11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot10(&mut self) -> _OT10W {
-                _OT10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot9(&mut self) -> _OT9W {
-                _OT9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot8(&mut self) -> _OT8W {
-                _OT8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot7(&mut self) -> _OT7W {
-                _OT7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot6(&mut self) -> _OT6W {
-                _OT6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot5(&mut self) -> _OT5W {
-                _OT5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot4(&mut self) -> _OT4W {
-                _OT4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot3(&mut self) -> _OT3W {
-                _OT3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot2(&mut self) -> _OT2W {
-                _OT2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot1(&mut self) -> _OT1W {
-                _OT1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot0(&mut self) -> _OT0W {
-                _OT0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port output speed register"]
-    pub struct OSPEEDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output speed register"]
-    pub mod ospeedr {
-        #[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::OSPEEDR {
-            #[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 = r" Value of the field"]
-        pub struct OSPEEDR15R {
-            bits: u8,
-        }
-        impl OSPEEDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR14R {
-            bits: u8,
-        }
-        impl OSPEEDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR13R {
-            bits: u8,
-        }
-        impl OSPEEDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR12R {
-            bits: u8,
-        }
-        impl OSPEEDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR11R {
-            bits: u8,
-        }
-        impl OSPEEDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR10R {
-            bits: u8,
-        }
-        impl OSPEEDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR9R {
-            bits: u8,
-        }
-        impl OSPEEDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR8R {
-            bits: u8,
-        }
-        impl OSPEEDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR7R {
-            bits: u8,
-        }
-        impl OSPEEDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR6R {
-            bits: u8,
-        }
-        impl OSPEEDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR5R {
-            bits: u8,
-        }
-        impl OSPEEDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR4R {
-            bits: u8,
-        }
-        impl OSPEEDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR3R {
-            bits: u8,
-        }
-        impl OSPEEDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR2R {
-            bits: u8,
-        }
-        impl OSPEEDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR1R {
-            bits: u8,
-        }
-        impl OSPEEDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR0R {
-            bits: u8,
-        }
-        impl OSPEEDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr15(&self) -> OSPEEDR15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr14(&self) -> OSPEEDR14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr13(&self) -> OSPEEDR13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr12(&self) -> OSPEEDR12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr11(&self) -> OSPEEDR11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr10(&self) -> OSPEEDR10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr9(&self) -> OSPEEDR9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr8(&self) -> OSPEEDR8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr7(&self) -> OSPEEDR7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr6(&self) -> OSPEEDR6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr5(&self) -> OSPEEDR5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr4(&self) -> OSPEEDR4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr3(&self) -> OSPEEDR3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr2(&self) -> OSPEEDR2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr1(&self) -> OSPEEDR1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr0(&self) -> OSPEEDR0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR0R { bits }
-            }
-        }
-        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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr15(&mut self) -> _OSPEEDR15W {
-                _OSPEEDR15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr14(&mut self) -> _OSPEEDR14W {
-                _OSPEEDR14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr13(&mut self) -> _OSPEEDR13W {
-                _OSPEEDR13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr12(&mut self) -> _OSPEEDR12W {
-                _OSPEEDR12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr11(&mut self) -> _OSPEEDR11W {
-                _OSPEEDR11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr10(&mut self) -> _OSPEEDR10W {
-                _OSPEEDR10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr9(&mut self) -> _OSPEEDR9W {
-                _OSPEEDR9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr8(&mut self) -> _OSPEEDR8W {
-                _OSPEEDR8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr7(&mut self) -> _OSPEEDR7W {
-                _OSPEEDR7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr6(&mut self) -> _OSPEEDR6W {
-                _OSPEEDR6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr5(&mut self) -> _OSPEEDR5W {
-                _OSPEEDR5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr4(&mut self) -> _OSPEEDR4W {
-                _OSPEEDR4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr3(&mut self) -> _OSPEEDR3W {
-                _OSPEEDR3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr2(&mut self) -> _OSPEEDR2W {
-                _OSPEEDR2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr1(&mut self) -> _OSPEEDR1W {
-                _OSPEEDR1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr0(&mut self) -> _OSPEEDR0W {
-                _OSPEEDR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port pull-up/pull-down register"]
-    pub struct PUPDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port pull-up/pull-down register"]
-    pub mod pupdr {
-        #[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::PUPDR {
-            #[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 = r" Value of the field"]
-        pub struct PUPDR15R {
-            bits: u8,
-        }
-        impl PUPDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR14R {
-            bits: u8,
-        }
-        impl PUPDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR13R {
-            bits: u8,
-        }
-        impl PUPDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR12R {
-            bits: u8,
-        }
-        impl PUPDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR11R {
-            bits: u8,
-        }
-        impl PUPDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR10R {
-            bits: u8,
-        }
-        impl PUPDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR9R {
-            bits: u8,
-        }
-        impl PUPDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR8R {
-            bits: u8,
-        }
-        impl PUPDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR7R {
-            bits: u8,
-        }
-        impl PUPDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR6R {
-            bits: u8,
-        }
-        impl PUPDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR5R {
-            bits: u8,
-        }
-        impl PUPDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR4R {
-            bits: u8,
-        }
-        impl PUPDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR3R {
-            bits: u8,
-        }
-        impl PUPDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR2R {
-            bits: u8,
-        }
-        impl PUPDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR1R {
-            bits: u8,
-        }
-        impl PUPDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR0R {
-            bits: u8,
-        }
-        impl PUPDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr15(&self) -> PUPDR15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr14(&self) -> PUPDR14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr13(&self) -> PUPDR13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr12(&self) -> PUPDR12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr11(&self) -> PUPDR11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr10(&self) -> PUPDR10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr9(&self) -> PUPDR9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr8(&self) -> PUPDR8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr7(&self) -> PUPDR7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr6(&self) -> PUPDR6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr5(&self) -> PUPDR5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr4(&self) -> PUPDR4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr3(&self) -> PUPDR3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr2(&self) -> PUPDR2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr1(&self) -> PUPDR1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr0(&self) -> PUPDR0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR0R { bits }
-            }
-        }
-        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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr15(&mut self) -> _PUPDR15W {
-                _PUPDR15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr14(&mut self) -> _PUPDR14W {
-                _PUPDR14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr13(&mut self) -> _PUPDR13W {
-                _PUPDR13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr12(&mut self) -> _PUPDR12W {
-                _PUPDR12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr11(&mut self) -> _PUPDR11W {
-                _PUPDR11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr10(&mut self) -> _PUPDR10W {
-                _PUPDR10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr9(&mut self) -> _PUPDR9W {
-                _PUPDR9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr8(&mut self) -> _PUPDR8W {
-                _PUPDR8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr7(&mut self) -> _PUPDR7W {
-                _PUPDR7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr6(&mut self) -> _PUPDR6W {
-                _PUPDR6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr5(&mut self) -> _PUPDR5W {
-                _PUPDR5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr4(&mut self) -> _PUPDR4W {
-                _PUPDR4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr3(&mut self) -> _PUPDR3W {
-                _PUPDR3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr2(&mut self) -> _PUPDR2W {
-                _PUPDR2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr1(&mut self) -> _PUPDR1W {
-                _PUPDR1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr0(&mut self) -> _PUPDR0W {
-                _PUPDR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port input data register"]
-    pub struct IDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port input data register"]
-    pub mod idr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::IDR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IDR15R {
-            bits: bool,
-        }
-        impl IDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR14R {
-            bits: bool,
-        }
-        impl IDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR13R {
-            bits: bool,
-        }
-        impl IDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR12R {
-            bits: bool,
-        }
-        impl IDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR11R {
-            bits: bool,
-        }
-        impl IDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR10R {
-            bits: bool,
-        }
-        impl IDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR9R {
-            bits: bool,
-        }
-        impl IDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR8R {
-            bits: bool,
-        }
-        impl IDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR7R {
-            bits: bool,
-        }
-        impl IDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR6R {
-            bits: bool,
-        }
-        impl IDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR5R {
-            bits: bool,
-        }
-        impl IDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR4R {
-            bits: bool,
-        }
-        impl IDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR3R {
-            bits: bool,
-        }
-        impl IDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR2R {
-            bits: bool,
-        }
-        impl IDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR1R {
-            bits: bool,
-        }
-        impl IDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR0R {
-            bits: bool,
-        }
-        impl IDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr15(&self) -> IDR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR15R { bits }
-            }
-            #[doc = "Bit 14 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr14(&self) -> IDR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR14R { bits }
-            }
-            #[doc = "Bit 13 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr13(&self) -> IDR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR13R { bits }
-            }
-            #[doc = "Bit 12 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr12(&self) -> IDR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR12R { bits }
-            }
-            #[doc = "Bit 11 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr11(&self) -> IDR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR11R { bits }
-            }
-            #[doc = "Bit 10 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr10(&self) -> IDR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR10R { bits }
-            }
-            #[doc = "Bit 9 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr9(&self) -> IDR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR9R { bits }
-            }
-            #[doc = "Bit 8 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr8(&self) -> IDR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR8R { bits }
-            }
-            #[doc = "Bit 7 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr7(&self) -> IDR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR7R { bits }
-            }
-            #[doc = "Bit 6 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr6(&self) -> IDR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR6R { bits }
-            }
-            #[doc = "Bit 5 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr5(&self) -> IDR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR5R { bits }
-            }
-            #[doc = "Bit 4 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr4(&self) -> IDR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR4R { bits }
-            }
-            #[doc = "Bit 3 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr3(&self) -> IDR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR3R { bits }
-            }
-            #[doc = "Bit 2 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr2(&self) -> IDR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR2R { bits }
-            }
-            #[doc = "Bit 1 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr1(&self) -> IDR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR1R { bits }
-            }
-            #[doc = "Bit 0 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr0(&self) -> IDR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR0R { bits }
-            }
-        }
-    }
-    #[doc = "GPIO port output data register"]
-    pub struct ODR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output data register"]
-    pub mod odr {
-        #[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::ODR {
-            #[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 = r" Value of the field"]
-        pub struct ODR15R {
-            bits: bool,
-        }
-        impl ODR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR14R {
-            bits: bool,
-        }
-        impl ODR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR13R {
-            bits: bool,
-        }
-        impl ODR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR12R {
-            bits: bool,
-        }
-        impl ODR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR11R {
-            bits: bool,
-        }
-        impl ODR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR10R {
-            bits: bool,
-        }
-        impl ODR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR9R {
-            bits: bool,
-        }
-        impl ODR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR8R {
-            bits: bool,
-        }
-        impl ODR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR7R {
-            bits: bool,
-        }
-        impl ODR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR6R {
-            bits: bool,
-        }
-        impl ODR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR5R {
-            bits: bool,
-        }
-        impl ODR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR4R {
-            bits: bool,
-        }
-        impl ODR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR3R {
-            bits: bool,
-        }
-        impl ODR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR2R {
-            bits: bool,
-        }
-        impl ODR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR1R {
-            bits: bool,
-        }
-        impl ODR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR0R {
-            bits: bool,
-        }
-        impl ODR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ODR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr15(&self) -> ODR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR15R { bits }
-            }
-            #[doc = "Bit 14 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr14(&self) -> ODR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR14R { bits }
-            }
-            #[doc = "Bit 13 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr13(&self) -> ODR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR13R { bits }
-            }
-            #[doc = "Bit 12 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr12(&self) -> ODR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR12R { bits }
-            }
-            #[doc = "Bit 11 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr11(&self) -> ODR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR11R { bits }
-            }
-            #[doc = "Bit 10 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr10(&self) -> ODR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR10R { bits }
-            }
-            #[doc = "Bit 9 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr9(&self) -> ODR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR9R { bits }
-            }
-            #[doc = "Bit 8 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr8(&self) -> ODR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR8R { bits }
-            }
-            #[doc = "Bit 7 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr7(&self) -> ODR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR7R { bits }
-            }
-            #[doc = "Bit 6 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr6(&self) -> ODR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR6R { bits }
-            }
-            #[doc = "Bit 5 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr5(&self) -> ODR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR5R { bits }
-            }
-            #[doc = "Bit 4 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr4(&self) -> ODR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR4R { bits }
-            }
-            #[doc = "Bit 3 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr3(&self) -> ODR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR3R { bits }
-            }
-            #[doc = "Bit 2 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr2(&self) -> ODR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR2R { bits }
-            }
-            #[doc = "Bit 1 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr1(&self) -> ODR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR1R { bits }
-            }
-            #[doc = "Bit 0 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr0(&self) -> ODR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR0R { bits }
-            }
-        }
-        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 15 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr15(&mut self) -> _ODR15W {
-                _ODR15W { w: self }
-            }
-            #[doc = "Bit 14 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr14(&mut self) -> _ODR14W {
-                _ODR14W { w: self }
-            }
-            #[doc = "Bit 13 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr13(&mut self) -> _ODR13W {
-                _ODR13W { w: self }
-            }
-            #[doc = "Bit 12 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr12(&mut self) -> _ODR12W {
-                _ODR12W { w: self }
-            }
-            #[doc = "Bit 11 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr11(&mut self) -> _ODR11W {
-                _ODR11W { w: self }
-            }
-            #[doc = "Bit 10 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr10(&mut self) -> _ODR10W {
-                _ODR10W { w: self }
-            }
-            #[doc = "Bit 9 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr9(&mut self) -> _ODR9W {
-                _ODR9W { w: self }
-            }
-            #[doc = "Bit 8 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr8(&mut self) -> _ODR8W {
-                _ODR8W { w: self }
-            }
-            #[doc = "Bit 7 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr7(&mut self) -> _ODR7W {
-                _ODR7W { w: self }
-            }
-            #[doc = "Bit 6 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr6(&mut self) -> _ODR6W {
-                _ODR6W { w: self }
-            }
-            #[doc = "Bit 5 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr5(&mut self) -> _ODR5W {
-                _ODR5W { w: self }
-            }
-            #[doc = "Bit 4 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr4(&mut self) -> _ODR4W {
-                _ODR4W { w: self }
-            }
-            #[doc = "Bit 3 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr3(&mut self) -> _ODR3W {
-                _ODR3W { w: self }
-            }
-            #[doc = "Bit 2 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr2(&mut self) -> _ODR2W {
-                _ODR2W { w: self }
-            }
-            #[doc = "Bit 1 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr1(&mut self) -> _ODR1W {
-                _ODR1W { w: self }
-            }
-            #[doc = "Bit 0 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr0(&mut self) -> _ODR0W {
-                _ODR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port bit set/reset register"]
-    pub struct BSRR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port bit set/reset register"]
-    pub mod bsrr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::BSRR {
-            #[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" Proxy"]
-        pub struct _BR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR15W<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS0W<'a> {
-            #[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
-            }
-        }
-        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 31 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br15(&mut self) -> _BR15W {
-                _BR15W { w: self }
-            }
-            #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br14(&mut self) -> _BR14W {
-                _BR14W { w: self }
-            }
-            #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br13(&mut self) -> _BR13W {
-                _BR13W { w: self }
-            }
-            #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br12(&mut self) -> _BR12W {
-                _BR12W { w: self }
-            }
-            #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br11(&mut self) -> _BR11W {
-                _BR11W { w: self }
-            }
-            #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br10(&mut self) -> _BR10W {
-                _BR10W { w: self }
-            }
-            #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br9(&mut self) -> _BR9W {
-                _BR9W { w: self }
-            }
-            #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br8(&mut self) -> _BR8W {
-                _BR8W { w: self }
-            }
-            #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br7(&mut self) -> _BR7W {
-                _BR7W { w: self }
-            }
-            #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br6(&mut self) -> _BR6W {
-                _BR6W { w: self }
-            }
-            #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br5(&mut self) -> _BR5W {
-                _BR5W { w: self }
-            }
-            #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br4(&mut self) -> _BR4W {
-                _BR4W { w: self }
-            }
-            #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br3(&mut self) -> _BR3W {
-                _BR3W { w: self }
-            }
-            #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br2(&mut self) -> _BR2W {
-                _BR2W { w: self }
-            }
-            #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br1(&mut self) -> _BR1W {
-                _BR1W { w: self }
-            }
-            #[doc = "Bit 16 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn br0(&mut self) -> _BR0W {
-                _BR0W { w: self }
-            }
-            #[doc = "Bit 15 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs15(&mut self) -> _BS15W {
-                _BS15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs14(&mut self) -> _BS14W {
-                _BS14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs13(&mut self) -> _BS13W {
-                _BS13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs12(&mut self) -> _BS12W {
-                _BS12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs11(&mut self) -> _BS11W {
-                _BS11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs10(&mut self) -> _BS10W {
-                _BS10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs9(&mut self) -> _BS9W {
-                _BS9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs8(&mut self) -> _BS8W {
-                _BS8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs7(&mut self) -> _BS7W {
-                _BS7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs6(&mut self) -> _BS6W {
-                _BS6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs5(&mut self) -> _BS5W {
-                _BS5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs4(&mut self) -> _BS4W {
-                _BS4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs3(&mut self) -> _BS3W {
-                _BS3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs2(&mut self) -> _BS2W {
-                _BS2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs1(&mut self) -> _BS1W {
-                _BS1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs0(&mut self) -> _BS0W {
-                _BS0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port configuration lock register"]
-    pub struct LCKR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port configuration lock register"]
-    pub mod lckr {
-        #[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::LCKR {
-            #[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 = r" Value of the field"]
-        pub struct LCKKR {
-            bits: bool,
-        }
-        impl LCKKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK15R {
-            bits: bool,
-        }
-        impl LCK15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK14R {
-            bits: bool,
-        }
-        impl LCK14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK13R {
-            bits: bool,
-        }
-        impl LCK13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK12R {
-            bits: bool,
-        }
-        impl LCK12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK11R {
-            bits: bool,
-        }
-        impl LCK11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK10R {
-            bits: bool,
-        }
-        impl LCK10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK9R {
-            bits: bool,
-        }
-        impl LCK9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK8R {
-            bits: bool,
-        }
-        impl LCK8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK7R {
-            bits: bool,
-        }
-        impl LCK7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK6R {
-            bits: bool,
-        }
-        impl LCK6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK5R {
-            bits: bool,
-        }
-        impl LCK5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK4R {
-            bits: bool,
-        }
-        impl LCK4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK3R {
-            bits: bool,
-        }
-        impl LCK3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK2R {
-            bits: bool,
-        }
-        impl LCK2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK1R {
-            bits: bool,
-        }
-        impl LCK1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK0R {
-            bits: bool,
-        }
-        impl LCK0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LCKKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCKKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lckk(&self) -> LCKKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCKKR { bits }
-            }
-            #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck15(&self) -> LCK15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK15R { bits }
-            }
-            #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck14(&self) -> LCK14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK14R { bits }
-            }
-            #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck13(&self) -> LCK13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK13R { bits }
-            }
-            #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck12(&self) -> LCK12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK12R { bits }
-            }
-            #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck11(&self) -> LCK11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK11R { bits }
-            }
-            #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck10(&self) -> LCK10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK10R { bits }
-            }
-            #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck9(&self) -> LCK9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK9R { bits }
-            }
-            #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck8(&self) -> LCK8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK8R { bits }
-            }
-            #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck7(&self) -> LCK7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK7R { bits }
-            }
-            #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck6(&self) -> LCK6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK6R { bits }
-            }
-            #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck5(&self) -> LCK5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK5R { bits }
-            }
-            #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck4(&self) -> LCK4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK4R { bits }
-            }
-            #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck3(&self) -> LCK3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK3R { bits }
-            }
-            #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck2(&self) -> LCK2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK2R { bits }
-            }
-            #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck1(&self) -> LCK1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK1R { bits }
-            }
-            #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck0(&self) -> LCK0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK0R { bits }
-            }
-        }
-        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 16 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lckk(&mut self) -> _LCKKW {
-                _LCKKW { w: self }
-            }
-            #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck15(&mut self) -> _LCK15W {
-                _LCK15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck14(&mut self) -> _LCK14W {
-                _LCK14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck13(&mut self) -> _LCK13W {
-                _LCK13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck12(&mut self) -> _LCK12W {
-                _LCK12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck11(&mut self) -> _LCK11W {
-                _LCK11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck10(&mut self) -> _LCK10W {
-                _LCK10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck9(&mut self) -> _LCK9W {
-                _LCK9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck8(&mut self) -> _LCK8W {
-                _LCK8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck7(&mut self) -> _LCK7W {
-                _LCK7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck6(&mut self) -> _LCK6W {
-                _LCK6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck5(&mut self) -> _LCK5W {
-                _LCK5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck4(&mut self) -> _LCK4W {
-                _LCK4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck3(&mut self) -> _LCK3W {
-                _LCK3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck2(&mut self) -> _LCK2W {
-                _LCK2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck1(&mut self) -> _LCK1W {
-                _LCK1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck0(&mut self) -> _LCK0W {
-                _LCK0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO alternate function low register"]
-    pub struct AFRL {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO alternate function low register"]
-    pub mod afrl {
-        #[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::AFRL {
-            #[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 = r" Value of the field"]
-        pub struct AFRL7R {
-            bits: u8,
-        }
-        impl AFRL7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL6R {
-            bits: u8,
-        }
-        impl AFRL6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL5R {
-            bits: u8,
-        }
-        impl AFRL5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL4R {
-            bits: u8,
-        }
-        impl AFRL4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL3R {
-            bits: u8,
-        }
-        impl AFRL3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL2R {
-            bits: u8,
-        }
-        impl AFRL2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL1R {
-            bits: u8,
-        }
-        impl AFRL1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL0R {
-            bits: u8,
-        }
-        impl AFRL0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:31 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl7(&self) -> AFRL7R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL7R { bits }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl6(&self) -> AFRL6R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL6R { bits }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl5(&self) -> AFRL5R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL5R { bits }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl4(&self) -> AFRL4R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL4R { bits }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl3(&self) -> AFRL3R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL3R { bits }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl2(&self) -> AFRL2R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL2R { bits }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl1(&self) -> AFRL1R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL1R { bits }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl0(&self) -> AFRL0R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL0R { bits }
-            }
-        }
-        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 28:31 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl7(&mut self) -> _AFRL7W {
-                _AFRL7W { w: self }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl6(&mut self) -> _AFRL6W {
-                _AFRL6W { w: self }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl5(&mut self) -> _AFRL5W {
-                _AFRL5W { w: self }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl4(&mut self) -> _AFRL4W {
-                _AFRL4W { w: self }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl3(&mut self) -> _AFRL3W {
-                _AFRL3W { w: self }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl2(&mut self) -> _AFRL2W {
-                _AFRL2W { w: self }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl1(&mut self) -> _AFRL1W {
-                _AFRL1W { w: self }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl0(&mut self) -> _AFRL0W {
-                _AFRL0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO alternate function high register"]
-    pub struct AFRH {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO alternate function high register"]
-    pub mod afrh {
-        #[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::AFRH {
-            #[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 = r" Value of the field"]
-        pub struct AFRH15R {
-            bits: u8,
-        }
-        impl AFRH15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH14R {
-            bits: u8,
-        }
-        impl AFRH14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH13R {
-            bits: u8,
-        }
-        impl AFRH13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH12R {
-            bits: u8,
-        }
-        impl AFRH12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH11R {
-            bits: u8,
-        }
-        impl AFRH11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH10R {
-            bits: u8,
-        }
-        impl AFRH10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH9R {
-            bits: u8,
-        }
-        impl AFRH9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH8R {
-            bits: u8,
-        }
-        impl AFRH8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:31 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh15(&self) -> AFRH15R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH15R { bits }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh14(&self) -> AFRH14R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH14R { bits }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh13(&self) -> AFRH13R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH13R { bits }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh12(&self) -> AFRH12R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH12R { bits }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh11(&self) -> AFRH11R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH11R { bits }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh10(&self) -> AFRH10R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH10R { bits }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh9(&self) -> AFRH9R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH9R { bits }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh8(&self) -> AFRH8R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH8R { bits }
-            }
-        }
-        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 28:31 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh15(&mut self) -> _AFRH15W {
-                _AFRH15W { w: self }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh14(&mut self) -> _AFRH14W {
-                _AFRH14W { w: self }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh13(&mut self) -> _AFRH13W {
-                _AFRH13W { w: self }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh12(&mut self) -> _AFRH12W {
-                _AFRH12W { w: self }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh11(&mut self) -> _AFRH11W {
-                _AFRH11W { w: self }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh10(&mut self) -> _AFRH10W {
-                _AFRH10W { w: self }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh9(&mut self) -> _AFRH9W {
-                _AFRH9W { w: self }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh8(&mut self) -> _AFRH8W {
-                _AFRH8W { w: self }
-            }
-        }
-    }
-}
-#[doc = "GPIOE"]
-pub struct GPIOE {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for GPIOE {}
-impl GPIOE {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const gpioh::RegisterBlock {
-        0x4002_1000 as *const _
-    }
-}
-impl Deref for GPIOE {
-    type Target = gpioh::RegisterBlock;
-    fn deref(&self) -> &gpioh::RegisterBlock {
-        unsafe { &*GPIOE::ptr() }
-    }
-}
-#[doc = "GPIOD"]
-pub struct GPIOD {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for GPIOD {}
-impl GPIOD {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const gpioh::RegisterBlock {
-        0x4002_0c00 as *const _
-    }
-}
-impl Deref for GPIOD {
-    type Target = gpioh::RegisterBlock;
-    fn deref(&self) -> &gpioh::RegisterBlock {
-        unsafe { &*GPIOD::ptr() }
-    }
-}
-#[doc = "GPIOC"]
-pub struct GPIOC {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for GPIOC {}
-impl GPIOC {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const gpioh::RegisterBlock {
-        0x4002_0800 as *const _
-    }
-}
-impl Deref for GPIOC {
-    type Target = gpioh::RegisterBlock;
-    fn deref(&self) -> &gpioh::RegisterBlock {
-        unsafe { &*GPIOC::ptr() }
-    }
-}
-#[doc = "GPIOF"]
-pub struct GPIOF {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for GPIOF {}
-impl GPIOF {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const gpioh::RegisterBlock {
-        0x4002_1400 as *const _
-    }
-}
-impl Deref for GPIOF {
-    type Target = gpioh::RegisterBlock;
-    fn deref(&self) -> &gpioh::RegisterBlock {
-        unsafe { &*GPIOF::ptr() }
-    }
-}
-#[doc = "GPIOG"]
-pub struct GPIOG {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for GPIOG {}
-impl GPIOG {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const gpioh::RegisterBlock {
-        0x4002_1800 as *const _
-    }
-}
-impl Deref for GPIOG {
-    type Target = gpioh::RegisterBlock;
-    fn deref(&self) -> &gpioh::RegisterBlock {
-        unsafe { &*GPIOG::ptr() }
-    }
-}
-#[doc = "General-purpose I/Os"]
-pub struct GPIOB {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for GPIOB {}
-impl GPIOB {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const gpiob::RegisterBlock {
-        0x4002_0400 as *const _
-    }
-}
-impl Deref for GPIOB {
-    type Target = gpiob::RegisterBlock;
-    fn deref(&self) -> &gpiob::RegisterBlock {
-        unsafe { &*GPIOB::ptr() }
-    }
-}
-#[doc = "General-purpose I/Os"]
-pub mod gpiob {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - GPIO port mode register"]
-        pub moder: MODER,
-        #[doc = "0x04 - GPIO port output type register"]
-        pub otyper: OTYPER,
-        #[doc = "0x08 - GPIO port output speed register"]
-        pub ospeedr: OSPEEDR,
-        #[doc = "0x0c - GPIO port pull-up/pull-down register"]
-        pub pupdr: PUPDR,
-        #[doc = "0x10 - GPIO port input data register"]
-        pub idr: IDR,
-        #[doc = "0x14 - GPIO port output data register"]
-        pub odr: ODR,
-        #[doc = "0x18 - GPIO port bit set/reset register"]
-        pub bsrr: BSRR,
-        #[doc = "0x1c - GPIO port configuration lock register"]
-        pub lckr: LCKR,
-        #[doc = "0x20 - GPIO alternate function low register"]
-        pub afrl: AFRL,
-        #[doc = "0x24 - GPIO alternate function high register"]
-        pub afrh: AFRH,
-    }
-    #[doc = "GPIO port mode register"]
-    pub struct MODER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port mode register"]
-    pub mod moder {
-        #[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::MODER {
-            #[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 = r" Value of the field"]
-        pub struct MODER15R {
-            bits: u8,
-        }
-        impl MODER15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER14R {
-            bits: u8,
-        }
-        impl MODER14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER13R {
-            bits: u8,
-        }
-        impl MODER13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER12R {
-            bits: u8,
-        }
-        impl MODER12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER11R {
-            bits: u8,
-        }
-        impl MODER11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER10R {
-            bits: u8,
-        }
-        impl MODER10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER9R {
-            bits: u8,
-        }
-        impl MODER9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER8R {
-            bits: u8,
-        }
-        impl MODER8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER7R {
-            bits: u8,
-        }
-        impl MODER7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER6R {
-            bits: u8,
-        }
-        impl MODER6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER5R {
-            bits: u8,
-        }
-        impl MODER5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER4R {
-            bits: u8,
-        }
-        impl MODER4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER3R {
-            bits: u8,
-        }
-        impl MODER3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER2R {
-            bits: u8,
-        }
-        impl MODER2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER1R {
-            bits: u8,
-        }
-        impl MODER1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER0R {
-            bits: u8,
-        }
-        impl MODER0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder15(&self) -> MODER15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder14(&self) -> MODER14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder13(&self) -> MODER13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder12(&self) -> MODER12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder11(&self) -> MODER11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder10(&self) -> MODER10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder9(&self) -> MODER9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder8(&self) -> MODER8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder7(&self) -> MODER7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder6(&self) -> MODER6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder5(&self) -> MODER5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder4(&self) -> MODER4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder3(&self) -> MODER3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder2(&self) -> MODER2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder1(&self) -> MODER1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder0(&self) -> MODER0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER0R { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0280 }
-            }
-            #[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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder15(&mut self) -> _MODER15W {
-                _MODER15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder14(&mut self) -> _MODER14W {
-                _MODER14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder13(&mut self) -> _MODER13W {
-                _MODER13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder12(&mut self) -> _MODER12W {
-                _MODER12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder11(&mut self) -> _MODER11W {
-                _MODER11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder10(&mut self) -> _MODER10W {
-                _MODER10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder9(&mut self) -> _MODER9W {
-                _MODER9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder8(&mut self) -> _MODER8W {
-                _MODER8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder7(&mut self) -> _MODER7W {
-                _MODER7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder6(&mut self) -> _MODER6W {
-                _MODER6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder5(&mut self) -> _MODER5W {
-                _MODER5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder4(&mut self) -> _MODER4W {
-                _MODER4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder3(&mut self) -> _MODER3W {
-                _MODER3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder2(&mut self) -> _MODER2W {
-                _MODER2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder1(&mut self) -> _MODER1W {
-                _MODER1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder0(&mut self) -> _MODER0W {
-                _MODER0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port output type register"]
-    pub struct OTYPER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output type register"]
-    pub mod otyper {
-        #[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::OTYPER {
-            #[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 = r" Value of the field"]
-        pub struct OT15R {
-            bits: bool,
-        }
-        impl OT15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT14R {
-            bits: bool,
-        }
-        impl OT14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT13R {
-            bits: bool,
-        }
-        impl OT13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT12R {
-            bits: bool,
-        }
-        impl OT12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT11R {
-            bits: bool,
-        }
-        impl OT11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT10R {
-            bits: bool,
-        }
-        impl OT10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT9R {
-            bits: bool,
-        }
-        impl OT9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT8R {
-            bits: bool,
-        }
-        impl OT8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT7R {
-            bits: bool,
-        }
-        impl OT7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT6R {
-            bits: bool,
-        }
-        impl OT6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT5R {
-            bits: bool,
-        }
-        impl OT5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT4R {
-            bits: bool,
-        }
-        impl OT4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT3R {
-            bits: bool,
-        }
-        impl OT3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT2R {
-            bits: bool,
-        }
-        impl OT2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT1R {
-            bits: bool,
-        }
-        impl OT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT0R {
-            bits: bool,
-        }
-        impl OT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OT15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot15(&self) -> OT15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT15R { bits }
-            }
-            #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot14(&self) -> OT14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT14R { bits }
-            }
-            #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot13(&self) -> OT13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT13R { bits }
-            }
-            #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot12(&self) -> OT12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT12R { bits }
-            }
-            #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot11(&self) -> OT11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT11R { bits }
-            }
-            #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot10(&self) -> OT10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT10R { bits }
-            }
-            #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot9(&self) -> OT9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT9R { bits }
-            }
-            #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot8(&self) -> OT8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT8R { bits }
-            }
-            #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot7(&self) -> OT7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT7R { bits }
-            }
-            #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot6(&self) -> OT6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT6R { bits }
-            }
-            #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot5(&self) -> OT5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT5R { bits }
-            }
-            #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot4(&self) -> OT4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT4R { bits }
-            }
-            #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot3(&self) -> OT3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT3R { bits }
-            }
-            #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot2(&self) -> OT2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT2R { bits }
-            }
-            #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot1(&self) -> OT1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT1R { bits }
-            }
-            #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot0(&self) -> OT0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT0R { bits }
-            }
-        }
-        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 15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot15(&mut self) -> _OT15W {
-                _OT15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot14(&mut self) -> _OT14W {
-                _OT14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot13(&mut self) -> _OT13W {
-                _OT13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot12(&mut self) -> _OT12W {
-                _OT12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot11(&mut self) -> _OT11W {
-                _OT11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot10(&mut self) -> _OT10W {
-                _OT10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot9(&mut self) -> _OT9W {
-                _OT9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot8(&mut self) -> _OT8W {
-                _OT8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot7(&mut self) -> _OT7W {
-                _OT7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot6(&mut self) -> _OT6W {
-                _OT6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot5(&mut self) -> _OT5W {
-                _OT5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot4(&mut self) -> _OT4W {
-                _OT4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot3(&mut self) -> _OT3W {
-                _OT3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot2(&mut self) -> _OT2W {
-                _OT2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot1(&mut self) -> _OT1W {
-                _OT1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot0(&mut self) -> _OT0W {
-                _OT0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port output speed register"]
-    pub struct OSPEEDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output speed register"]
-    pub mod ospeedr {
-        #[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::OSPEEDR {
-            #[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 = r" Value of the field"]
-        pub struct OSPEEDR15R {
-            bits: u8,
-        }
-        impl OSPEEDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR14R {
-            bits: u8,
-        }
-        impl OSPEEDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR13R {
-            bits: u8,
-        }
-        impl OSPEEDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR12R {
-            bits: u8,
-        }
-        impl OSPEEDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR11R {
-            bits: u8,
-        }
-        impl OSPEEDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR10R {
-            bits: u8,
-        }
-        impl OSPEEDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR9R {
-            bits: u8,
-        }
-        impl OSPEEDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR8R {
-            bits: u8,
-        }
-        impl OSPEEDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR7R {
-            bits: u8,
-        }
-        impl OSPEEDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR6R {
-            bits: u8,
-        }
-        impl OSPEEDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR5R {
-            bits: u8,
-        }
-        impl OSPEEDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR4R {
-            bits: u8,
-        }
-        impl OSPEEDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR3R {
-            bits: u8,
-        }
-        impl OSPEEDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR2R {
-            bits: u8,
-        }
-        impl OSPEEDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR1R {
-            bits: u8,
-        }
-        impl OSPEEDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR0R {
-            bits: u8,
-        }
-        impl OSPEEDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr15(&self) -> OSPEEDR15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr14(&self) -> OSPEEDR14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr13(&self) -> OSPEEDR13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr12(&self) -> OSPEEDR12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr11(&self) -> OSPEEDR11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr10(&self) -> OSPEEDR10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr9(&self) -> OSPEEDR9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr8(&self) -> OSPEEDR8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr7(&self) -> OSPEEDR7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr6(&self) -> OSPEEDR6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr5(&self) -> OSPEEDR5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr4(&self) -> OSPEEDR4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr3(&self) -> OSPEEDR3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr2(&self) -> OSPEEDR2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr1(&self) -> OSPEEDR1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr0(&self) -> OSPEEDR0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR0R { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xc0 }
-            }
-            #[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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr15(&mut self) -> _OSPEEDR15W {
-                _OSPEEDR15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr14(&mut self) -> _OSPEEDR14W {
-                _OSPEEDR14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr13(&mut self) -> _OSPEEDR13W {
-                _OSPEEDR13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr12(&mut self) -> _OSPEEDR12W {
-                _OSPEEDR12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr11(&mut self) -> _OSPEEDR11W {
-                _OSPEEDR11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr10(&mut self) -> _OSPEEDR10W {
-                _OSPEEDR10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr9(&mut self) -> _OSPEEDR9W {
-                _OSPEEDR9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr8(&mut self) -> _OSPEEDR8W {
-                _OSPEEDR8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr7(&mut self) -> _OSPEEDR7W {
-                _OSPEEDR7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr6(&mut self) -> _OSPEEDR6W {
-                _OSPEEDR6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr5(&mut self) -> _OSPEEDR5W {
-                _OSPEEDR5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr4(&mut self) -> _OSPEEDR4W {
-                _OSPEEDR4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr3(&mut self) -> _OSPEEDR3W {
-                _OSPEEDR3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr2(&mut self) -> _OSPEEDR2W {
-                _OSPEEDR2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr1(&mut self) -> _OSPEEDR1W {
-                _OSPEEDR1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr0(&mut self) -> _OSPEEDR0W {
-                _OSPEEDR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port pull-up/pull-down register"]
-    pub struct PUPDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port pull-up/pull-down register"]
-    pub mod pupdr {
-        #[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::PUPDR {
-            #[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 = r" Value of the field"]
-        pub struct PUPDR15R {
-            bits: u8,
-        }
-        impl PUPDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR14R {
-            bits: u8,
-        }
-        impl PUPDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR13R {
-            bits: u8,
-        }
-        impl PUPDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR12R {
-            bits: u8,
-        }
-        impl PUPDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR11R {
-            bits: u8,
-        }
-        impl PUPDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR10R {
-            bits: u8,
-        }
-        impl PUPDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR9R {
-            bits: u8,
-        }
-        impl PUPDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR8R {
-            bits: u8,
-        }
-        impl PUPDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR7R {
-            bits: u8,
-        }
-        impl PUPDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR6R {
-            bits: u8,
-        }
-        impl PUPDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR5R {
-            bits: u8,
-        }
-        impl PUPDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR4R {
-            bits: u8,
-        }
-        impl PUPDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR3R {
-            bits: u8,
-        }
-        impl PUPDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR2R {
-            bits: u8,
-        }
-        impl PUPDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR1R {
-            bits: u8,
-        }
-        impl PUPDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR0R {
-            bits: u8,
-        }
-        impl PUPDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr15(&self) -> PUPDR15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr14(&self) -> PUPDR14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr13(&self) -> PUPDR13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr12(&self) -> PUPDR12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr11(&self) -> PUPDR11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr10(&self) -> PUPDR10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr9(&self) -> PUPDR9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr8(&self) -> PUPDR8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr7(&self) -> PUPDR7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr6(&self) -> PUPDR6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr5(&self) -> PUPDR5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr4(&self) -> PUPDR4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr3(&self) -> PUPDR3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr2(&self) -> PUPDR2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr1(&self) -> PUPDR1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr0(&self) -> PUPDR0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR0R { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0100 }
-            }
-            #[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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr15(&mut self) -> _PUPDR15W {
-                _PUPDR15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr14(&mut self) -> _PUPDR14W {
-                _PUPDR14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr13(&mut self) -> _PUPDR13W {
-                _PUPDR13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr12(&mut self) -> _PUPDR12W {
-                _PUPDR12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr11(&mut self) -> _PUPDR11W {
-                _PUPDR11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr10(&mut self) -> _PUPDR10W {
-                _PUPDR10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr9(&mut self) -> _PUPDR9W {
-                _PUPDR9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr8(&mut self) -> _PUPDR8W {
-                _PUPDR8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr7(&mut self) -> _PUPDR7W {
-                _PUPDR7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr6(&mut self) -> _PUPDR6W {
-                _PUPDR6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr5(&mut self) -> _PUPDR5W {
-                _PUPDR5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr4(&mut self) -> _PUPDR4W {
-                _PUPDR4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr3(&mut self) -> _PUPDR3W {
-                _PUPDR3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr2(&mut self) -> _PUPDR2W {
-                _PUPDR2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr1(&mut self) -> _PUPDR1W {
-                _PUPDR1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr0(&mut self) -> _PUPDR0W {
-                _PUPDR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port input data register"]
-    pub struct IDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port input data register"]
-    pub mod idr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::IDR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IDR15R {
-            bits: bool,
-        }
-        impl IDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR14R {
-            bits: bool,
-        }
-        impl IDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR13R {
-            bits: bool,
-        }
-        impl IDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR12R {
-            bits: bool,
-        }
-        impl IDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR11R {
-            bits: bool,
-        }
-        impl IDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR10R {
-            bits: bool,
-        }
-        impl IDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR9R {
-            bits: bool,
-        }
-        impl IDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR8R {
-            bits: bool,
-        }
-        impl IDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR7R {
-            bits: bool,
-        }
-        impl IDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR6R {
-            bits: bool,
-        }
-        impl IDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR5R {
-            bits: bool,
-        }
-        impl IDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR4R {
-            bits: bool,
-        }
-        impl IDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR3R {
-            bits: bool,
-        }
-        impl IDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR2R {
-            bits: bool,
-        }
-        impl IDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR1R {
-            bits: bool,
-        }
-        impl IDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR0R {
-            bits: bool,
-        }
-        impl IDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr15(&self) -> IDR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR15R { bits }
-            }
-            #[doc = "Bit 14 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr14(&self) -> IDR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR14R { bits }
-            }
-            #[doc = "Bit 13 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr13(&self) -> IDR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR13R { bits }
-            }
-            #[doc = "Bit 12 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr12(&self) -> IDR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR12R { bits }
-            }
-            #[doc = "Bit 11 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr11(&self) -> IDR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR11R { bits }
-            }
-            #[doc = "Bit 10 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr10(&self) -> IDR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR10R { bits }
-            }
-            #[doc = "Bit 9 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr9(&self) -> IDR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR9R { bits }
-            }
-            #[doc = "Bit 8 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr8(&self) -> IDR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR8R { bits }
-            }
-            #[doc = "Bit 7 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr7(&self) -> IDR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR7R { bits }
-            }
-            #[doc = "Bit 6 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr6(&self) -> IDR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR6R { bits }
-            }
-            #[doc = "Bit 5 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr5(&self) -> IDR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR5R { bits }
-            }
-            #[doc = "Bit 4 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr4(&self) -> IDR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR4R { bits }
-            }
-            #[doc = "Bit 3 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr3(&self) -> IDR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR3R { bits }
-            }
-            #[doc = "Bit 2 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr2(&self) -> IDR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR2R { bits }
-            }
-            #[doc = "Bit 1 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr1(&self) -> IDR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR1R { bits }
-            }
-            #[doc = "Bit 0 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr0(&self) -> IDR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR0R { bits }
-            }
-        }
-    }
-    #[doc = "GPIO port output data register"]
-    pub struct ODR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output data register"]
-    pub mod odr {
-        #[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::ODR {
-            #[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 = r" Value of the field"]
-        pub struct ODR15R {
-            bits: bool,
-        }
-        impl ODR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR14R {
-            bits: bool,
-        }
-        impl ODR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR13R {
-            bits: bool,
-        }
-        impl ODR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR12R {
-            bits: bool,
-        }
-        impl ODR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR11R {
-            bits: bool,
-        }
-        impl ODR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR10R {
-            bits: bool,
-        }
-        impl ODR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR9R {
-            bits: bool,
-        }
-        impl ODR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR8R {
-            bits: bool,
-        }
-        impl ODR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR7R {
-            bits: bool,
-        }
-        impl ODR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR6R {
-            bits: bool,
-        }
-        impl ODR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR5R {
-            bits: bool,
-        }
-        impl ODR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR4R {
-            bits: bool,
-        }
-        impl ODR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR3R {
-            bits: bool,
-        }
-        impl ODR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR2R {
-            bits: bool,
-        }
-        impl ODR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR1R {
-            bits: bool,
-        }
-        impl ODR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR0R {
-            bits: bool,
-        }
-        impl ODR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ODR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr15(&self) -> ODR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR15R { bits }
-            }
-            #[doc = "Bit 14 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr14(&self) -> ODR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR14R { bits }
-            }
-            #[doc = "Bit 13 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr13(&self) -> ODR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR13R { bits }
-            }
-            #[doc = "Bit 12 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr12(&self) -> ODR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR12R { bits }
-            }
-            #[doc = "Bit 11 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr11(&self) -> ODR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR11R { bits }
-            }
-            #[doc = "Bit 10 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr10(&self) -> ODR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR10R { bits }
-            }
-            #[doc = "Bit 9 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr9(&self) -> ODR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR9R { bits }
-            }
-            #[doc = "Bit 8 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr8(&self) -> ODR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR8R { bits }
-            }
-            #[doc = "Bit 7 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr7(&self) -> ODR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR7R { bits }
-            }
-            #[doc = "Bit 6 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr6(&self) -> ODR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR6R { bits }
-            }
-            #[doc = "Bit 5 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr5(&self) -> ODR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR5R { bits }
-            }
-            #[doc = "Bit 4 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr4(&self) -> ODR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR4R { bits }
-            }
-            #[doc = "Bit 3 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr3(&self) -> ODR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR3R { bits }
-            }
-            #[doc = "Bit 2 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr2(&self) -> ODR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR2R { bits }
-            }
-            #[doc = "Bit 1 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr1(&self) -> ODR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR1R { bits }
-            }
-            #[doc = "Bit 0 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr0(&self) -> ODR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR0R { bits }
-            }
-        }
-        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 15 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr15(&mut self) -> _ODR15W {
-                _ODR15W { w: self }
-            }
-            #[doc = "Bit 14 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr14(&mut self) -> _ODR14W {
-                _ODR14W { w: self }
-            }
-            #[doc = "Bit 13 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr13(&mut self) -> _ODR13W {
-                _ODR13W { w: self }
-            }
-            #[doc = "Bit 12 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr12(&mut self) -> _ODR12W {
-                _ODR12W { w: self }
-            }
-            #[doc = "Bit 11 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr11(&mut self) -> _ODR11W {
-                _ODR11W { w: self }
-            }
-            #[doc = "Bit 10 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr10(&mut self) -> _ODR10W {
-                _ODR10W { w: self }
-            }
-            #[doc = "Bit 9 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr9(&mut self) -> _ODR9W {
-                _ODR9W { w: self }
-            }
-            #[doc = "Bit 8 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr8(&mut self) -> _ODR8W {
-                _ODR8W { w: self }
-            }
-            #[doc = "Bit 7 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr7(&mut self) -> _ODR7W {
-                _ODR7W { w: self }
-            }
-            #[doc = "Bit 6 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr6(&mut self) -> _ODR6W {
-                _ODR6W { w: self }
-            }
-            #[doc = "Bit 5 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr5(&mut self) -> _ODR5W {
-                _ODR5W { w: self }
-            }
-            #[doc = "Bit 4 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr4(&mut self) -> _ODR4W {
-                _ODR4W { w: self }
-            }
-            #[doc = "Bit 3 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr3(&mut self) -> _ODR3W {
-                _ODR3W { w: self }
-            }
-            #[doc = "Bit 2 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr2(&mut self) -> _ODR2W {
-                _ODR2W { w: self }
-            }
-            #[doc = "Bit 1 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr1(&mut self) -> _ODR1W {
-                _ODR1W { w: self }
-            }
-            #[doc = "Bit 0 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr0(&mut self) -> _ODR0W {
-                _ODR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port bit set/reset register"]
-    pub struct BSRR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port bit set/reset register"]
-    pub mod bsrr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::BSRR {
-            #[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" Proxy"]
-        pub struct _BR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR15W<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS0W<'a> {
-            #[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
-            }
-        }
-        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 31 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br15(&mut self) -> _BR15W {
-                _BR15W { w: self }
-            }
-            #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br14(&mut self) -> _BR14W {
-                _BR14W { w: self }
-            }
-            #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br13(&mut self) -> _BR13W {
-                _BR13W { w: self }
-            }
-            #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br12(&mut self) -> _BR12W {
-                _BR12W { w: self }
-            }
-            #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br11(&mut self) -> _BR11W {
-                _BR11W { w: self }
-            }
-            #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br10(&mut self) -> _BR10W {
-                _BR10W { w: self }
-            }
-            #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br9(&mut self) -> _BR9W {
-                _BR9W { w: self }
-            }
-            #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br8(&mut self) -> _BR8W {
-                _BR8W { w: self }
-            }
-            #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br7(&mut self) -> _BR7W {
-                _BR7W { w: self }
-            }
-            #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br6(&mut self) -> _BR6W {
-                _BR6W { w: self }
-            }
-            #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br5(&mut self) -> _BR5W {
-                _BR5W { w: self }
-            }
-            #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br4(&mut self) -> _BR4W {
-                _BR4W { w: self }
-            }
-            #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br3(&mut self) -> _BR3W {
-                _BR3W { w: self }
-            }
-            #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br2(&mut self) -> _BR2W {
-                _BR2W { w: self }
-            }
-            #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br1(&mut self) -> _BR1W {
-                _BR1W { w: self }
-            }
-            #[doc = "Bit 16 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn br0(&mut self) -> _BR0W {
-                _BR0W { w: self }
-            }
-            #[doc = "Bit 15 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs15(&mut self) -> _BS15W {
-                _BS15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs14(&mut self) -> _BS14W {
-                _BS14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs13(&mut self) -> _BS13W {
-                _BS13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs12(&mut self) -> _BS12W {
-                _BS12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs11(&mut self) -> _BS11W {
-                _BS11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs10(&mut self) -> _BS10W {
-                _BS10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs9(&mut self) -> _BS9W {
-                _BS9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs8(&mut self) -> _BS8W {
-                _BS8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs7(&mut self) -> _BS7W {
-                _BS7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs6(&mut self) -> _BS6W {
-                _BS6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs5(&mut self) -> _BS5W {
-                _BS5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs4(&mut self) -> _BS4W {
-                _BS4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs3(&mut self) -> _BS3W {
-                _BS3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs2(&mut self) -> _BS2W {
-                _BS2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs1(&mut self) -> _BS1W {
-                _BS1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs0(&mut self) -> _BS0W {
-                _BS0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port configuration lock register"]
-    pub struct LCKR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port configuration lock register"]
-    pub mod lckr {
-        #[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::LCKR {
-            #[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 = r" Value of the field"]
-        pub struct LCKKR {
-            bits: bool,
-        }
-        impl LCKKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK15R {
-            bits: bool,
-        }
-        impl LCK15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK14R {
-            bits: bool,
-        }
-        impl LCK14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK13R {
-            bits: bool,
-        }
-        impl LCK13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK12R {
-            bits: bool,
-        }
-        impl LCK12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK11R {
-            bits: bool,
-        }
-        impl LCK11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK10R {
-            bits: bool,
-        }
-        impl LCK10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK9R {
-            bits: bool,
-        }
-        impl LCK9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK8R {
-            bits: bool,
-        }
-        impl LCK8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK7R {
-            bits: bool,
-        }
-        impl LCK7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK6R {
-            bits: bool,
-        }
-        impl LCK6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK5R {
-            bits: bool,
-        }
-        impl LCK5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK4R {
-            bits: bool,
-        }
-        impl LCK4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK3R {
-            bits: bool,
-        }
-        impl LCK3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK2R {
-            bits: bool,
-        }
-        impl LCK2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK1R {
-            bits: bool,
-        }
-        impl LCK1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK0R {
-            bits: bool,
-        }
-        impl LCK0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LCKKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCKKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lckk(&self) -> LCKKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCKKR { bits }
-            }
-            #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck15(&self) -> LCK15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK15R { bits }
-            }
-            #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck14(&self) -> LCK14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK14R { bits }
-            }
-            #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck13(&self) -> LCK13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK13R { bits }
-            }
-            #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck12(&self) -> LCK12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK12R { bits }
-            }
-            #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck11(&self) -> LCK11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK11R { bits }
-            }
-            #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck10(&self) -> LCK10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK10R { bits }
-            }
-            #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck9(&self) -> LCK9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK9R { bits }
-            }
-            #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck8(&self) -> LCK8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK8R { bits }
-            }
-            #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck7(&self) -> LCK7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK7R { bits }
-            }
-            #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck6(&self) -> LCK6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK6R { bits }
-            }
-            #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck5(&self) -> LCK5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK5R { bits }
-            }
-            #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck4(&self) -> LCK4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK4R { bits }
-            }
-            #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck3(&self) -> LCK3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK3R { bits }
-            }
-            #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck2(&self) -> LCK2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK2R { bits }
-            }
-            #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck1(&self) -> LCK1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK1R { bits }
-            }
-            #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck0(&self) -> LCK0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK0R { bits }
-            }
-        }
-        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 16 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lckk(&mut self) -> _LCKKW {
-                _LCKKW { w: self }
-            }
-            #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck15(&mut self) -> _LCK15W {
-                _LCK15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck14(&mut self) -> _LCK14W {
-                _LCK14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck13(&mut self) -> _LCK13W {
-                _LCK13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck12(&mut self) -> _LCK12W {
-                _LCK12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck11(&mut self) -> _LCK11W {
-                _LCK11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck10(&mut self) -> _LCK10W {
-                _LCK10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck9(&mut self) -> _LCK9W {
-                _LCK9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck8(&mut self) -> _LCK8W {
-                _LCK8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck7(&mut self) -> _LCK7W {
-                _LCK7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck6(&mut self) -> _LCK6W {
-                _LCK6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck5(&mut self) -> _LCK5W {
-                _LCK5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck4(&mut self) -> _LCK4W {
-                _LCK4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck3(&mut self) -> _LCK3W {
-                _LCK3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck2(&mut self) -> _LCK2W {
-                _LCK2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck1(&mut self) -> _LCK1W {
-                _LCK1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck0(&mut self) -> _LCK0W {
-                _LCK0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO alternate function low register"]
-    pub struct AFRL {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO alternate function low register"]
-    pub mod afrl {
-        #[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::AFRL {
-            #[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 = r" Value of the field"]
-        pub struct AFRL7R {
-            bits: u8,
-        }
-        impl AFRL7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL6R {
-            bits: u8,
-        }
-        impl AFRL6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL5R {
-            bits: u8,
-        }
-        impl AFRL5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL4R {
-            bits: u8,
-        }
-        impl AFRL4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL3R {
-            bits: u8,
-        }
-        impl AFRL3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL2R {
-            bits: u8,
-        }
-        impl AFRL2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL1R {
-            bits: u8,
-        }
-        impl AFRL1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL0R {
-            bits: u8,
-        }
-        impl AFRL0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:31 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl7(&self) -> AFRL7R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL7R { bits }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl6(&self) -> AFRL6R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL6R { bits }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl5(&self) -> AFRL5R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL5R { bits }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl4(&self) -> AFRL4R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL4R { bits }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl3(&self) -> AFRL3R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL3R { bits }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl2(&self) -> AFRL2R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL2R { bits }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl1(&self) -> AFRL1R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL1R { bits }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl0(&self) -> AFRL0R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL0R { bits }
-            }
-        }
-        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 28:31 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl7(&mut self) -> _AFRL7W {
-                _AFRL7W { w: self }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl6(&mut self) -> _AFRL6W {
-                _AFRL6W { w: self }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl5(&mut self) -> _AFRL5W {
-                _AFRL5W { w: self }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl4(&mut self) -> _AFRL4W {
-                _AFRL4W { w: self }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl3(&mut self) -> _AFRL3W {
-                _AFRL3W { w: self }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl2(&mut self) -> _AFRL2W {
-                _AFRL2W { w: self }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl1(&mut self) -> _AFRL1W {
-                _AFRL1W { w: self }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl0(&mut self) -> _AFRL0W {
-                _AFRL0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO alternate function high register"]
-    pub struct AFRH {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO alternate function high register"]
-    pub mod afrh {
-        #[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::AFRH {
-            #[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 = r" Value of the field"]
-        pub struct AFRH15R {
-            bits: u8,
-        }
-        impl AFRH15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH14R {
-            bits: u8,
-        }
-        impl AFRH14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH13R {
-            bits: u8,
-        }
-        impl AFRH13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH12R {
-            bits: u8,
-        }
-        impl AFRH12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH11R {
-            bits: u8,
-        }
-        impl AFRH11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH10R {
-            bits: u8,
-        }
-        impl AFRH10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH9R {
-            bits: u8,
-        }
-        impl AFRH9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH8R {
-            bits: u8,
-        }
-        impl AFRH8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:31 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh15(&self) -> AFRH15R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH15R { bits }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh14(&self) -> AFRH14R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH14R { bits }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh13(&self) -> AFRH13R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH13R { bits }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh12(&self) -> AFRH12R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH12R { bits }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh11(&self) -> AFRH11R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH11R { bits }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh10(&self) -> AFRH10R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH10R { bits }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh9(&self) -> AFRH9R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH9R { bits }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh8(&self) -> AFRH8R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH8R { bits }
-            }
-        }
-        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 28:31 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh15(&mut self) -> _AFRH15W {
-                _AFRH15W { w: self }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh14(&mut self) -> _AFRH14W {
-                _AFRH14W { w: self }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh13(&mut self) -> _AFRH13W {
-                _AFRH13W { w: self }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh12(&mut self) -> _AFRH12W {
-                _AFRH12W { w: self }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh11(&mut self) -> _AFRH11W {
-                _AFRH11W { w: self }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh10(&mut self) -> _AFRH10W {
-                _AFRH10W { w: self }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh9(&mut self) -> _AFRH9W {
-                _AFRH9W { w: self }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh8(&mut self) -> _AFRH8W {
-                _AFRH8W { w: self }
-            }
-        }
-    }
-}
-#[doc = "General-purpose I/Os"]
-pub struct GPIOA {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for GPIOA {}
-impl GPIOA {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const gpioa::RegisterBlock {
-        0x4002_0000 as *const _
-    }
-}
-impl Deref for GPIOA {
-    type Target = gpioa::RegisterBlock;
-    fn deref(&self) -> &gpioa::RegisterBlock {
-        unsafe { &*GPIOA::ptr() }
-    }
-}
-#[doc = "General-purpose I/Os"]
-pub mod gpioa {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - GPIO port mode register"]
-        pub moder: MODER,
-        #[doc = "0x04 - GPIO port output type register"]
-        pub otyper: OTYPER,
-        #[doc = "0x08 - GPIO port output speed register"]
-        pub ospeedr: OSPEEDR,
-        #[doc = "0x0c - GPIO port pull-up/pull-down register"]
-        pub pupdr: PUPDR,
-        #[doc = "0x10 - GPIO port input data register"]
-        pub idr: IDR,
-        #[doc = "0x14 - GPIO port output data register"]
-        pub odr: ODR,
-        #[doc = "0x18 - GPIO port bit set/reset register"]
-        pub bsrr: BSRR,
-        #[doc = "0x1c - GPIO port configuration lock register"]
-        pub lckr: LCKR,
-        #[doc = "0x20 - GPIO alternate function low register"]
-        pub afrl: AFRL,
-        #[doc = "0x24 - GPIO alternate function high register"]
-        pub afrh: AFRH,
-    }
-    #[doc = "GPIO port mode register"]
-    pub struct MODER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port mode register"]
-    pub mod moder {
-        #[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::MODER {
-            #[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 = r" Value of the field"]
-        pub struct MODER15R {
-            bits: u8,
-        }
-        impl MODER15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER14R {
-            bits: u8,
-        }
-        impl MODER14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER13R {
-            bits: u8,
-        }
-        impl MODER13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER12R {
-            bits: u8,
-        }
-        impl MODER12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER11R {
-            bits: u8,
-        }
-        impl MODER11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER10R {
-            bits: u8,
-        }
-        impl MODER10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER9R {
-            bits: u8,
-        }
-        impl MODER9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER8R {
-            bits: u8,
-        }
-        impl MODER8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER7R {
-            bits: u8,
-        }
-        impl MODER7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER6R {
-            bits: u8,
-        }
-        impl MODER6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER5R {
-            bits: u8,
-        }
-        impl MODER5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER4R {
-            bits: u8,
-        }
-        impl MODER4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER3R {
-            bits: u8,
-        }
-        impl MODER3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER2R {
-            bits: u8,
-        }
-        impl MODER2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER1R {
-            bits: u8,
-        }
-        impl MODER1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER0R {
-            bits: u8,
-        }
-        impl MODER0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODER0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODER0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder15(&self) -> MODER15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder14(&self) -> MODER14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder13(&self) -> MODER13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder12(&self) -> MODER12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder11(&self) -> MODER11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder10(&self) -> MODER10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder9(&self) -> MODER9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder8(&self) -> MODER8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder7(&self) -> MODER7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder6(&self) -> MODER6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder5(&self) -> MODER5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder4(&self) -> MODER4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder3(&self) -> MODER3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder2(&self) -> MODER2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder1(&self) -> MODER1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder0(&self) -> MODER0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER0R { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xa800_0000 }
-            }
-            #[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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder15(&mut self) -> _MODER15W {
-                _MODER15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder14(&mut self) -> _MODER14W {
-                _MODER14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder13(&mut self) -> _MODER13W {
-                _MODER13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder12(&mut self) -> _MODER12W {
-                _MODER12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder11(&mut self) -> _MODER11W {
-                _MODER11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder10(&mut self) -> _MODER10W {
-                _MODER10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder9(&mut self) -> _MODER9W {
-                _MODER9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder8(&mut self) -> _MODER8W {
-                _MODER8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder7(&mut self) -> _MODER7W {
-                _MODER7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder6(&mut self) -> _MODER6W {
-                _MODER6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder5(&mut self) -> _MODER5W {
-                _MODER5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder4(&mut self) -> _MODER4W {
-                _MODER4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder3(&mut self) -> _MODER3W {
-                _MODER3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder2(&mut self) -> _MODER2W {
-                _MODER2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder1(&mut self) -> _MODER1W {
-                _MODER1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn moder0(&mut self) -> _MODER0W {
-                _MODER0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port output type register"]
-    pub struct OTYPER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output type register"]
-    pub mod otyper {
-        #[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::OTYPER {
-            #[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 = r" Value of the field"]
-        pub struct OT15R {
-            bits: bool,
-        }
-        impl OT15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT14R {
-            bits: bool,
-        }
-        impl OT14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT13R {
-            bits: bool,
-        }
-        impl OT13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT12R {
-            bits: bool,
-        }
-        impl OT12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT11R {
-            bits: bool,
-        }
-        impl OT11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT10R {
-            bits: bool,
-        }
-        impl OT10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT9R {
-            bits: bool,
-        }
-        impl OT9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT8R {
-            bits: bool,
-        }
-        impl OT8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT7R {
-            bits: bool,
-        }
-        impl OT7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT6R {
-            bits: bool,
-        }
-        impl OT6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT5R {
-            bits: bool,
-        }
-        impl OT5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT4R {
-            bits: bool,
-        }
-        impl OT4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT3R {
-            bits: bool,
-        }
-        impl OT3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT2R {
-            bits: bool,
-        }
-        impl OT2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT1R {
-            bits: bool,
-        }
-        impl OT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OT0R {
-            bits: bool,
-        }
-        impl OT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OT15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OT0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot15(&self) -> OT15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT15R { bits }
-            }
-            #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot14(&self) -> OT14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT14R { bits }
-            }
-            #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot13(&self) -> OT13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT13R { bits }
-            }
-            #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot12(&self) -> OT12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT12R { bits }
-            }
-            #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot11(&self) -> OT11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT11R { bits }
-            }
-            #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot10(&self) -> OT10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT10R { bits }
-            }
-            #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot9(&self) -> OT9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT9R { bits }
-            }
-            #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot8(&self) -> OT8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT8R { bits }
-            }
-            #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot7(&self) -> OT7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT7R { bits }
-            }
-            #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot6(&self) -> OT6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT6R { bits }
-            }
-            #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot5(&self) -> OT5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT5R { bits }
-            }
-            #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot4(&self) -> OT4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT4R { bits }
-            }
-            #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot3(&self) -> OT3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT3R { bits }
-            }
-            #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot2(&self) -> OT2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT2R { bits }
-            }
-            #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot1(&self) -> OT1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT1R { bits }
-            }
-            #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot0(&self) -> OT0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OT0R { bits }
-            }
-        }
-        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 15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot15(&mut self) -> _OT15W {
-                _OT15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot14(&mut self) -> _OT14W {
-                _OT14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot13(&mut self) -> _OT13W {
-                _OT13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot12(&mut self) -> _OT12W {
-                _OT12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot11(&mut self) -> _OT11W {
-                _OT11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot10(&mut self) -> _OT10W {
-                _OT10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot9(&mut self) -> _OT9W {
-                _OT9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot8(&mut self) -> _OT8W {
-                _OT8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot7(&mut self) -> _OT7W {
-                _OT7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot6(&mut self) -> _OT6W {
-                _OT6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot5(&mut self) -> _OT5W {
-                _OT5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot4(&mut self) -> _OT4W {
-                _OT4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot3(&mut self) -> _OT3W {
-                _OT3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot2(&mut self) -> _OT2W {
-                _OT2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot1(&mut self) -> _OT1W {
-                _OT1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ot0(&mut self) -> _OT0W {
-                _OT0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port output speed register"]
-    pub struct OSPEEDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output speed register"]
-    pub mod ospeedr {
-        #[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::OSPEEDR {
-            #[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 = r" Value of the field"]
-        pub struct OSPEEDR15R {
-            bits: u8,
-        }
-        impl OSPEEDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR14R {
-            bits: u8,
-        }
-        impl OSPEEDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR13R {
-            bits: u8,
-        }
-        impl OSPEEDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR12R {
-            bits: u8,
-        }
-        impl OSPEEDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR11R {
-            bits: u8,
-        }
-        impl OSPEEDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR10R {
-            bits: u8,
-        }
-        impl OSPEEDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR9R {
-            bits: u8,
-        }
-        impl OSPEEDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR8R {
-            bits: u8,
-        }
-        impl OSPEEDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR7R {
-            bits: u8,
-        }
-        impl OSPEEDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR6R {
-            bits: u8,
-        }
-        impl OSPEEDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR5R {
-            bits: u8,
-        }
-        impl OSPEEDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR4R {
-            bits: u8,
-        }
-        impl OSPEEDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR3R {
-            bits: u8,
-        }
-        impl OSPEEDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR2R {
-            bits: u8,
-        }
-        impl OSPEEDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR1R {
-            bits: u8,
-        }
-        impl OSPEEDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OSPEEDR0R {
-            bits: u8,
-        }
-        impl OSPEEDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OSPEEDR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OSPEEDR0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr15(&self) -> OSPEEDR15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr14(&self) -> OSPEEDR14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr13(&self) -> OSPEEDR13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr12(&self) -> OSPEEDR12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr11(&self) -> OSPEEDR11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr10(&self) -> OSPEEDR10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr9(&self) -> OSPEEDR9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr8(&self) -> OSPEEDR8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr7(&self) -> OSPEEDR7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr6(&self) -> OSPEEDR6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr5(&self) -> OSPEEDR5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr4(&self) -> OSPEEDR4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr3(&self) -> OSPEEDR3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr2(&self) -> OSPEEDR2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr1(&self) -> OSPEEDR1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr0(&self) -> OSPEEDR0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OSPEEDR0R { bits }
-            }
-        }
-        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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr15(&mut self) -> _OSPEEDR15W {
-                _OSPEEDR15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr14(&mut self) -> _OSPEEDR14W {
-                _OSPEEDR14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr13(&mut self) -> _OSPEEDR13W {
-                _OSPEEDR13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr12(&mut self) -> _OSPEEDR12W {
-                _OSPEEDR12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr11(&mut self) -> _OSPEEDR11W {
-                _OSPEEDR11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr10(&mut self) -> _OSPEEDR10W {
-                _OSPEEDR10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr9(&mut self) -> _OSPEEDR9W {
-                _OSPEEDR9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr8(&mut self) -> _OSPEEDR8W {
-                _OSPEEDR8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr7(&mut self) -> _OSPEEDR7W {
-                _OSPEEDR7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr6(&mut self) -> _OSPEEDR6W {
-                _OSPEEDR6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr5(&mut self) -> _OSPEEDR5W {
-                _OSPEEDR5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr4(&mut self) -> _OSPEEDR4W {
-                _OSPEEDR4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr3(&mut self) -> _OSPEEDR3W {
-                _OSPEEDR3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr2(&mut self) -> _OSPEEDR2W {
-                _OSPEEDR2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr1(&mut self) -> _OSPEEDR1W {
-                _OSPEEDR1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn ospeedr0(&mut self) -> _OSPEEDR0W {
-                _OSPEEDR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port pull-up/pull-down register"]
-    pub struct PUPDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port pull-up/pull-down register"]
-    pub mod pupdr {
-        #[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::PUPDR {
-            #[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 = r" Value of the field"]
-        pub struct PUPDR15R {
-            bits: u8,
-        }
-        impl PUPDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR14R {
-            bits: u8,
-        }
-        impl PUPDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR13R {
-            bits: u8,
-        }
-        impl PUPDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR12R {
-            bits: u8,
-        }
-        impl PUPDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR11R {
-            bits: u8,
-        }
-        impl PUPDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR10R {
-            bits: u8,
-        }
-        impl PUPDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR9R {
-            bits: u8,
-        }
-        impl PUPDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR8R {
-            bits: u8,
-        }
-        impl PUPDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR7R {
-            bits: u8,
-        }
-        impl PUPDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR6R {
-            bits: u8,
-        }
-        impl PUPDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR5R {
-            bits: u8,
-        }
-        impl PUPDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR4R {
-            bits: u8,
-        }
-        impl PUPDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR3R {
-            bits: u8,
-        }
-        impl PUPDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR2R {
-            bits: u8,
-        }
-        impl PUPDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR1R {
-            bits: u8,
-        }
-        impl PUPDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PUPDR0R {
-            bits: u8,
-        }
-        impl PUPDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 30;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PUPDR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PUPDR0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr15(&self) -> PUPDR15R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR15R { bits }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr14(&self) -> PUPDR14R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR14R { bits }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr13(&self) -> PUPDR13R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR13R { bits }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr12(&self) -> PUPDR12R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR12R { bits }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr11(&self) -> PUPDR11R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR11R { bits }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr10(&self) -> PUPDR10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR10R { bits }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr9(&self) -> PUPDR9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR9R { bits }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr8(&self) -> PUPDR8R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR8R { bits }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr7(&self) -> PUPDR7R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR7R { bits }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr6(&self) -> PUPDR6R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR6R { bits }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr5(&self) -> PUPDR5R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR5R { bits }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr4(&self) -> PUPDR4R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR4R { bits }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr3(&self) -> PUPDR3R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR3R { bits }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr2(&self) -> PUPDR2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR2R { bits }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr1(&self) -> PUPDR1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR1R { bits }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr0(&self) -> PUPDR0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PUPDR0R { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x6400_0000 }
-            }
-            #[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 30:31 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr15(&mut self) -> _PUPDR15W {
-                _PUPDR15W { w: self }
-            }
-            #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr14(&mut self) -> _PUPDR14W {
-                _PUPDR14W { w: self }
-            }
-            #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr13(&mut self) -> _PUPDR13W {
-                _PUPDR13W { w: self }
-            }
-            #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr12(&mut self) -> _PUPDR12W {
-                _PUPDR12W { w: self }
-            }
-            #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr11(&mut self) -> _PUPDR11W {
-                _PUPDR11W { w: self }
-            }
-            #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr10(&mut self) -> _PUPDR10W {
-                _PUPDR10W { w: self }
-            }
-            #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr9(&mut self) -> _PUPDR9W {
-                _PUPDR9W { w: self }
-            }
-            #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr8(&mut self) -> _PUPDR8W {
-                _PUPDR8W { w: self }
-            }
-            #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr7(&mut self) -> _PUPDR7W {
-                _PUPDR7W { w: self }
-            }
-            #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr6(&mut self) -> _PUPDR6W {
-                _PUPDR6W { w: self }
-            }
-            #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr5(&mut self) -> _PUPDR5W {
-                _PUPDR5W { w: self }
-            }
-            #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr4(&mut self) -> _PUPDR4W {
-                _PUPDR4W { w: self }
-            }
-            #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr3(&mut self) -> _PUPDR3W {
-                _PUPDR3W { w: self }
-            }
-            #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr2(&mut self) -> _PUPDR2W {
-                _PUPDR2W { w: self }
-            }
-            #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr1(&mut self) -> _PUPDR1W {
-                _PUPDR1W { w: self }
-            }
-            #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
-            #[inline]
-            pub fn pupdr0(&mut self) -> _PUPDR0W {
-                _PUPDR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port input data register"]
-    pub struct IDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port input data register"]
-    pub mod idr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::IDR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IDR15R {
-            bits: bool,
-        }
-        impl IDR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR14R {
-            bits: bool,
-        }
-        impl IDR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR13R {
-            bits: bool,
-        }
-        impl IDR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR12R {
-            bits: bool,
-        }
-        impl IDR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR11R {
-            bits: bool,
-        }
-        impl IDR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR10R {
-            bits: bool,
-        }
-        impl IDR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR9R {
-            bits: bool,
-        }
-        impl IDR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR8R {
-            bits: bool,
-        }
-        impl IDR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR7R {
-            bits: bool,
-        }
-        impl IDR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR6R {
-            bits: bool,
-        }
-        impl IDR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR5R {
-            bits: bool,
-        }
-        impl IDR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR4R {
-            bits: bool,
-        }
-        impl IDR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR3R {
-            bits: bool,
-        }
-        impl IDR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR2R {
-            bits: bool,
-        }
-        impl IDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR1R {
-            bits: bool,
-        }
-        impl IDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IDR0R {
-            bits: bool,
-        }
-        impl IDR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr15(&self) -> IDR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR15R { bits }
-            }
-            #[doc = "Bit 14 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr14(&self) -> IDR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR14R { bits }
-            }
-            #[doc = "Bit 13 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr13(&self) -> IDR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR13R { bits }
-            }
-            #[doc = "Bit 12 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr12(&self) -> IDR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR12R { bits }
-            }
-            #[doc = "Bit 11 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr11(&self) -> IDR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR11R { bits }
-            }
-            #[doc = "Bit 10 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr10(&self) -> IDR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR10R { bits }
-            }
-            #[doc = "Bit 9 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr9(&self) -> IDR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR9R { bits }
-            }
-            #[doc = "Bit 8 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr8(&self) -> IDR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR8R { bits }
-            }
-            #[doc = "Bit 7 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr7(&self) -> IDR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR7R { bits }
-            }
-            #[doc = "Bit 6 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr6(&self) -> IDR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR6R { bits }
-            }
-            #[doc = "Bit 5 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr5(&self) -> IDR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR5R { bits }
-            }
-            #[doc = "Bit 4 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr4(&self) -> IDR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR4R { bits }
-            }
-            #[doc = "Bit 3 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr3(&self) -> IDR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR3R { bits }
-            }
-            #[doc = "Bit 2 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr2(&self) -> IDR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR2R { bits }
-            }
-            #[doc = "Bit 1 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr1(&self) -> IDR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR1R { bits }
-            }
-            #[doc = "Bit 0 - Port input data (y = 0..15)"]
-            #[inline]
-            pub fn idr0(&self) -> IDR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDR0R { bits }
-            }
-        }
-    }
-    #[doc = "GPIO port output data register"]
-    pub struct ODR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port output data register"]
-    pub mod odr {
-        #[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::ODR {
-            #[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 = r" Value of the field"]
-        pub struct ODR15R {
-            bits: bool,
-        }
-        impl ODR15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR14R {
-            bits: bool,
-        }
-        impl ODR14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR13R {
-            bits: bool,
-        }
-        impl ODR13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR12R {
-            bits: bool,
-        }
-        impl ODR12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR11R {
-            bits: bool,
-        }
-        impl ODR11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR10R {
-            bits: bool,
-        }
-        impl ODR10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR9R {
-            bits: bool,
-        }
-        impl ODR9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR8R {
-            bits: bool,
-        }
-        impl ODR8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR7R {
-            bits: bool,
-        }
-        impl ODR7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR6R {
-            bits: bool,
-        }
-        impl ODR6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR5R {
-            bits: bool,
-        }
-        impl ODR5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR4R {
-            bits: bool,
-        }
-        impl ODR4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR3R {
-            bits: bool,
-        }
-        impl ODR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR2R {
-            bits: bool,
-        }
-        impl ODR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR1R {
-            bits: bool,
-        }
-        impl ODR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODR0R {
-            bits: bool,
-        }
-        impl ODR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ODR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODR0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr15(&self) -> ODR15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR15R { bits }
-            }
-            #[doc = "Bit 14 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr14(&self) -> ODR14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR14R { bits }
-            }
-            #[doc = "Bit 13 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr13(&self) -> ODR13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR13R { bits }
-            }
-            #[doc = "Bit 12 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr12(&self) -> ODR12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR12R { bits }
-            }
-            #[doc = "Bit 11 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr11(&self) -> ODR11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR11R { bits }
-            }
-            #[doc = "Bit 10 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr10(&self) -> ODR10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR10R { bits }
-            }
-            #[doc = "Bit 9 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr9(&self) -> ODR9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR9R { bits }
-            }
-            #[doc = "Bit 8 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr8(&self) -> ODR8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR8R { bits }
-            }
-            #[doc = "Bit 7 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr7(&self) -> ODR7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR7R { bits }
-            }
-            #[doc = "Bit 6 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr6(&self) -> ODR6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR6R { bits }
-            }
-            #[doc = "Bit 5 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr5(&self) -> ODR5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR5R { bits }
-            }
-            #[doc = "Bit 4 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr4(&self) -> ODR4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR4R { bits }
-            }
-            #[doc = "Bit 3 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr3(&self) -> ODR3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR3R { bits }
-            }
-            #[doc = "Bit 2 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr2(&self) -> ODR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR2R { bits }
-            }
-            #[doc = "Bit 1 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr1(&self) -> ODR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR1R { bits }
-            }
-            #[doc = "Bit 0 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr0(&self) -> ODR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODR0R { bits }
-            }
-        }
-        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 15 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr15(&mut self) -> _ODR15W {
-                _ODR15W { w: self }
-            }
-            #[doc = "Bit 14 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr14(&mut self) -> _ODR14W {
-                _ODR14W { w: self }
-            }
-            #[doc = "Bit 13 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr13(&mut self) -> _ODR13W {
-                _ODR13W { w: self }
-            }
-            #[doc = "Bit 12 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr12(&mut self) -> _ODR12W {
-                _ODR12W { w: self }
-            }
-            #[doc = "Bit 11 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr11(&mut self) -> _ODR11W {
-                _ODR11W { w: self }
-            }
-            #[doc = "Bit 10 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr10(&mut self) -> _ODR10W {
-                _ODR10W { w: self }
-            }
-            #[doc = "Bit 9 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr9(&mut self) -> _ODR9W {
-                _ODR9W { w: self }
-            }
-            #[doc = "Bit 8 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr8(&mut self) -> _ODR8W {
-                _ODR8W { w: self }
-            }
-            #[doc = "Bit 7 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr7(&mut self) -> _ODR7W {
-                _ODR7W { w: self }
-            }
-            #[doc = "Bit 6 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr6(&mut self) -> _ODR6W {
-                _ODR6W { w: self }
-            }
-            #[doc = "Bit 5 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr5(&mut self) -> _ODR5W {
-                _ODR5W { w: self }
-            }
-            #[doc = "Bit 4 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr4(&mut self) -> _ODR4W {
-                _ODR4W { w: self }
-            }
-            #[doc = "Bit 3 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr3(&mut self) -> _ODR3W {
-                _ODR3W { w: self }
-            }
-            #[doc = "Bit 2 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr2(&mut self) -> _ODR2W {
-                _ODR2W { w: self }
-            }
-            #[doc = "Bit 1 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr1(&mut self) -> _ODR1W {
-                _ODR1W { w: self }
-            }
-            #[doc = "Bit 0 - Port output data (y = 0..15)"]
-            #[inline]
-            pub fn odr0(&mut self) -> _ODR0W {
-                _ODR0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port bit set/reset register"]
-    pub struct BSRR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port bit set/reset register"]
-    pub mod bsrr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::BSRR {
-            #[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" Proxy"]
-        pub struct _BR15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR15W<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BR14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BS0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BS0W<'a> {
-            #[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
-            }
-        }
-        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 31 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br15(&mut self) -> _BR15W {
-                _BR15W { w: self }
-            }
-            #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br14(&mut self) -> _BR14W {
-                _BR14W { w: self }
-            }
-            #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br13(&mut self) -> _BR13W {
-                _BR13W { w: self }
-            }
-            #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br12(&mut self) -> _BR12W {
-                _BR12W { w: self }
-            }
-            #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br11(&mut self) -> _BR11W {
-                _BR11W { w: self }
-            }
-            #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br10(&mut self) -> _BR10W {
-                _BR10W { w: self }
-            }
-            #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br9(&mut self) -> _BR9W {
-                _BR9W { w: self }
-            }
-            #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br8(&mut self) -> _BR8W {
-                _BR8W { w: self }
-            }
-            #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br7(&mut self) -> _BR7W {
-                _BR7W { w: self }
-            }
-            #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br6(&mut self) -> _BR6W {
-                _BR6W { w: self }
-            }
-            #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br5(&mut self) -> _BR5W {
-                _BR5W { w: self }
-            }
-            #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br4(&mut self) -> _BR4W {
-                _BR4W { w: self }
-            }
-            #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br3(&mut self) -> _BR3W {
-                _BR3W { w: self }
-            }
-            #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br2(&mut self) -> _BR2W {
-                _BR2W { w: self }
-            }
-            #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"]
-            #[inline]
-            pub fn br1(&mut self) -> _BR1W {
-                _BR1W { w: self }
-            }
-            #[doc = "Bit 16 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn br0(&mut self) -> _BR0W {
-                _BR0W { w: self }
-            }
-            #[doc = "Bit 15 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs15(&mut self) -> _BS15W {
-                _BS15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs14(&mut self) -> _BS14W {
-                _BS14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs13(&mut self) -> _BS13W {
-                _BS13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs12(&mut self) -> _BS12W {
-                _BS12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs11(&mut self) -> _BS11W {
-                _BS11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs10(&mut self) -> _BS10W {
-                _BS10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs9(&mut self) -> _BS9W {
-                _BS9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs8(&mut self) -> _BS8W {
-                _BS8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs7(&mut self) -> _BS7W {
-                _BS7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs6(&mut self) -> _BS6W {
-                _BS6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs5(&mut self) -> _BS5W {
-                _BS5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs4(&mut self) -> _BS4W {
-                _BS4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs3(&mut self) -> _BS3W {
-                _BS3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs2(&mut self) -> _BS2W {
-                _BS2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs1(&mut self) -> _BS1W {
-                _BS1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x set bit y (y= 0..15)"]
-            #[inline]
-            pub fn bs0(&mut self) -> _BS0W {
-                _BS0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO port configuration lock register"]
-    pub struct LCKR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO port configuration lock register"]
-    pub mod lckr {
-        #[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::LCKR {
-            #[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 = r" Value of the field"]
-        pub struct LCKKR {
-            bits: bool,
-        }
-        impl LCKKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK15R {
-            bits: bool,
-        }
-        impl LCK15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK14R {
-            bits: bool,
-        }
-        impl LCK14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK13R {
-            bits: bool,
-        }
-        impl LCK13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK12R {
-            bits: bool,
-        }
-        impl LCK12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK11R {
-            bits: bool,
-        }
-        impl LCK11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK10R {
-            bits: bool,
-        }
-        impl LCK10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK9R {
-            bits: bool,
-        }
-        impl LCK9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK8R {
-            bits: bool,
-        }
-        impl LCK8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK7R {
-            bits: bool,
-        }
-        impl LCK7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK6R {
-            bits: bool,
-        }
-        impl LCK6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK5R {
-            bits: bool,
-        }
-        impl LCK5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK4R {
-            bits: bool,
-        }
-        impl LCK4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK3R {
-            bits: bool,
-        }
-        impl LCK3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK2R {
-            bits: bool,
-        }
-        impl LCK2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK1R {
-            bits: bool,
-        }
-        impl LCK1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LCK0R {
-            bits: bool,
-        }
-        impl LCK0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LCKKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCKKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LCK0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LCK0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lckk(&self) -> LCKKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCKKR { bits }
-            }
-            #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck15(&self) -> LCK15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK15R { bits }
-            }
-            #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck14(&self) -> LCK14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK14R { bits }
-            }
-            #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck13(&self) -> LCK13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK13R { bits }
-            }
-            #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck12(&self) -> LCK12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK12R { bits }
-            }
-            #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck11(&self) -> LCK11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK11R { bits }
-            }
-            #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck10(&self) -> LCK10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK10R { bits }
-            }
-            #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck9(&self) -> LCK9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK9R { bits }
-            }
-            #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck8(&self) -> LCK8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK8R { bits }
-            }
-            #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck7(&self) -> LCK7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK7R { bits }
-            }
-            #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck6(&self) -> LCK6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK6R { bits }
-            }
-            #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck5(&self) -> LCK5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK5R { bits }
-            }
-            #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck4(&self) -> LCK4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK4R { bits }
-            }
-            #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck3(&self) -> LCK3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK3R { bits }
-            }
-            #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck2(&self) -> LCK2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK2R { bits }
-            }
-            #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck1(&self) -> LCK1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK1R { bits }
-            }
-            #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck0(&self) -> LCK0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LCK0R { bits }
-            }
-        }
-        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 16 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lckk(&mut self) -> _LCKKW {
-                _LCKKW { w: self }
-            }
-            #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck15(&mut self) -> _LCK15W {
-                _LCK15W { w: self }
-            }
-            #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck14(&mut self) -> _LCK14W {
-                _LCK14W { w: self }
-            }
-            #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck13(&mut self) -> _LCK13W {
-                _LCK13W { w: self }
-            }
-            #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck12(&mut self) -> _LCK12W {
-                _LCK12W { w: self }
-            }
-            #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck11(&mut self) -> _LCK11W {
-                _LCK11W { w: self }
-            }
-            #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck10(&mut self) -> _LCK10W {
-                _LCK10W { w: self }
-            }
-            #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck9(&mut self) -> _LCK9W {
-                _LCK9W { w: self }
-            }
-            #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck8(&mut self) -> _LCK8W {
-                _LCK8W { w: self }
-            }
-            #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck7(&mut self) -> _LCK7W {
-                _LCK7W { w: self }
-            }
-            #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck6(&mut self) -> _LCK6W {
-                _LCK6W { w: self }
-            }
-            #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck5(&mut self) -> _LCK5W {
-                _LCK5W { w: self }
-            }
-            #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck4(&mut self) -> _LCK4W {
-                _LCK4W { w: self }
-            }
-            #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck3(&mut self) -> _LCK3W {
-                _LCK3W { w: self }
-            }
-            #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck2(&mut self) -> _LCK2W {
-                _LCK2W { w: self }
-            }
-            #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck1(&mut self) -> _LCK1W {
-                _LCK1W { w: self }
-            }
-            #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"]
-            #[inline]
-            pub fn lck0(&mut self) -> _LCK0W {
-                _LCK0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO alternate function low register"]
-    pub struct AFRL {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO alternate function low register"]
-    pub mod afrl {
-        #[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::AFRL {
-            #[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 = r" Value of the field"]
-        pub struct AFRL7R {
-            bits: u8,
-        }
-        impl AFRL7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL6R {
-            bits: u8,
-        }
-        impl AFRL6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL5R {
-            bits: u8,
-        }
-        impl AFRL5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL4R {
-            bits: u8,
-        }
-        impl AFRL4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL3R {
-            bits: u8,
-        }
-        impl AFRL3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL2R {
-            bits: u8,
-        }
-        impl AFRL2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL1R {
-            bits: u8,
-        }
-        impl AFRL1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRL0R {
-            bits: u8,
-        }
-        impl AFRL0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRL0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRL0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:31 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl7(&self) -> AFRL7R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL7R { bits }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl6(&self) -> AFRL6R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL6R { bits }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl5(&self) -> AFRL5R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL5R { bits }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl4(&self) -> AFRL4R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL4R { bits }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl3(&self) -> AFRL3R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL3R { bits }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl2(&self) -> AFRL2R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL2R { bits }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl1(&self) -> AFRL1R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL1R { bits }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl0(&self) -> AFRL0R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRL0R { bits }
-            }
-        }
-        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 28:31 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl7(&mut self) -> _AFRL7W {
-                _AFRL7W { w: self }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl6(&mut self) -> _AFRL6W {
-                _AFRL6W { w: self }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl5(&mut self) -> _AFRL5W {
-                _AFRL5W { w: self }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl4(&mut self) -> _AFRL4W {
-                _AFRL4W { w: self }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl3(&mut self) -> _AFRL3W {
-                _AFRL3W { w: self }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl2(&mut self) -> _AFRL2W {
-                _AFRL2W { w: self }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl1(&mut self) -> _AFRL1W {
-                _AFRL1W { w: self }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"]
-            #[inline]
-            pub fn afrl0(&mut self) -> _AFRL0W {
-                _AFRL0W { w: self }
-            }
-        }
-    }
-    #[doc = "GPIO alternate function high register"]
-    pub struct AFRH {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "GPIO alternate function high register"]
-    pub mod afrh {
-        #[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::AFRH {
-            #[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 = r" Value of the field"]
-        pub struct AFRH15R {
-            bits: u8,
-        }
-        impl AFRH15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH14R {
-            bits: u8,
-        }
-        impl AFRH14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH13R {
-            bits: u8,
-        }
-        impl AFRH13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH12R {
-            bits: u8,
-        }
-        impl AFRH12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH11R {
-            bits: u8,
-        }
-        impl AFRH11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH10R {
-            bits: u8,
-        }
-        impl AFRH10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH9R {
-            bits: u8,
-        }
-        impl AFRH9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AFRH8R {
-            bits: u8,
-        }
-        impl AFRH8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH15W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH14W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH13W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH12W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH11W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AFRH8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFRH8W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:31 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh15(&self) -> AFRH15R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH15R { bits }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh14(&self) -> AFRH14R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH14R { bits }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh13(&self) -> AFRH13R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH13R { bits }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh12(&self) -> AFRH12R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH12R { bits }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh11(&self) -> AFRH11R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH11R { bits }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh10(&self) -> AFRH10R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH10R { bits }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh9(&self) -> AFRH9R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH9R { bits }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh8(&self) -> AFRH8R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AFRH8R { bits }
-            }
-        }
-        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 28:31 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh15(&mut self) -> _AFRH15W {
-                _AFRH15W { w: self }
-            }
-            #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh14(&mut self) -> _AFRH14W {
-                _AFRH14W { w: self }
-            }
-            #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh13(&mut self) -> _AFRH13W {
-                _AFRH13W { w: self }
-            }
-            #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh12(&mut self) -> _AFRH12W {
-                _AFRH12W { w: self }
-            }
-            #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh11(&mut self) -> _AFRH11W {
-                _AFRH11W { w: self }
-            }
-            #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh10(&mut self) -> _AFRH10W {
-                _AFRH10W { w: self }
-            }
-            #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh9(&mut self) -> _AFRH9W {
-                _AFRH9W { w: self }
-            }
-            #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"]
-            #[inline]
-            pub fn afrh8(&mut self) -> _AFRH8W {
-                _AFRH8W { w: self }
-            }
-        }
-    }
-}
-#[doc = "Inter-integrated circuit"]
-pub struct I2C3 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for I2C3 {}
-impl I2C3 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2c3::RegisterBlock {
-        0x4000_5c00 as *const _
-    }
-}
-impl Deref for I2C3 {
-    type Target = i2c3::RegisterBlock;
-    fn deref(&self) -> &i2c3::RegisterBlock {
-        unsafe { &*I2C3::ptr() }
-    }
-}
-#[doc = "Inter-integrated circuit"]
-pub mod i2c3 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - Control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x08 - Own address register 1"]
-        pub oar1: OAR1,
-        #[doc = "0x0c - Own address register 2"]
-        pub oar2: OAR2,
-        #[doc = "0x10 - Data register"]
-        pub dr: DR,
-        #[doc = "0x14 - Status register 1"]
-        pub sr1: SR1,
-        #[doc = "0x18 - Status register 2"]
-        pub sr2: SR2,
-        #[doc = "0x1c - Clock control register"]
-        pub ccr: CCR,
-        #[doc = "0x20 - TRISE register"]
-        pub trise: TRISE,
-    }
-    #[doc = "Control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct SWRSTR {
-            bits: bool,
-        }
-        impl SWRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALERTR {
-            bits: bool,
-        }
-        impl ALERTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PECR {
-            bits: bool,
-        }
-        impl PECR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct POSR {
-            bits: bool,
-        }
-        impl POSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STOPR {
-            bits: bool,
-        }
-        impl STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STARTR {
-            bits: bool,
-        }
-        impl STARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NOSTRETCHR {
-            bits: bool,
-        }
-        impl NOSTRETCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENGCR {
-            bits: bool,
-        }
-        impl ENGCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENPECR {
-            bits: bool,
-        }
-        impl ENPECR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENARPR {
-            bits: bool,
-        }
-        impl ENARPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SMBTYPER {
-            bits: bool,
-        }
-        impl SMBTYPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SMBUSR {
-            bits: bool,
-        }
-        impl SMBUSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PER {
-            bits: bool,
-        }
-        impl PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SWRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALERTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALERTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PECW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PECW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _POSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _POSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NOSTRETCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NOSTRETCHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENGCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENGCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENPECW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENPECW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENARPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENARPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SMBTYPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMBTYPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SMBUSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMBUSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Software reset"]
-            #[inline]
-            pub fn swrst(&self) -> SWRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SWRSTR { bits }
-            }
-            #[doc = "Bit 13 - SMBus alert"]
-            #[inline]
-            pub fn alert(&self) -> ALERTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALERTR { bits }
-            }
-            #[doc = "Bit 12 - Packet error checking"]
-            #[inline]
-            pub fn pec(&self) -> PECR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PECR { bits }
-            }
-            #[doc = "Bit 11 - Acknowledge/PEC Position (for data reception)"]
-            #[inline]
-            pub fn pos(&self) -> POSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                POSR { bits }
-            }
-            #[doc = "Bit 10 - Acknowledge enable"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 9 - Stop generation"]
-            #[inline]
-            pub fn stop(&self) -> STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STOPR { bits }
-            }
-            #[doc = "Bit 8 - Start generation"]
-            #[inline]
-            pub fn start(&self) -> STARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STARTR { bits }
-            }
-            #[doc = "Bit 7 - Clock stretching disable (Slave mode)"]
-            #[inline]
-            pub fn nostretch(&self) -> NOSTRETCHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NOSTRETCHR { bits }
-            }
-            #[doc = "Bit 6 - General call enable"]
-            #[inline]
-            pub fn engc(&self) -> ENGCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENGCR { bits }
-            }
-            #[doc = "Bit 5 - PEC enable"]
-            #[inline]
-            pub fn enpec(&self) -> ENPECR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENPECR { bits }
-            }
-            #[doc = "Bit 4 - ARP enable"]
-            #[inline]
-            pub fn enarp(&self) -> ENARPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENARPR { bits }
-            }
-            #[doc = "Bit 3 - SMBus type"]
-            #[inline]
-            pub fn smbtype(&self) -> SMBTYPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMBTYPER { bits }
-            }
-            #[doc = "Bit 1 - SMBus mode"]
-            #[inline]
-            pub fn smbus(&self) -> SMBUSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMBUSR { bits }
-            }
-            #[doc = "Bit 0 - Peripheral enable"]
-            #[inline]
-            pub fn pe(&self) -> PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PER { bits }
-            }
-        }
-        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 15 - Software reset"]
-            #[inline]
-            pub fn swrst(&mut self) -> _SWRSTW {
-                _SWRSTW { w: self }
-            }
-            #[doc = "Bit 13 - SMBus alert"]
-            #[inline]
-            pub fn alert(&mut self) -> _ALERTW {
-                _ALERTW { w: self }
-            }
-            #[doc = "Bit 12 - Packet error checking"]
-            #[inline]
-            pub fn pec(&mut self) -> _PECW {
-                _PECW { w: self }
-            }
-            #[doc = "Bit 11 - Acknowledge/PEC Position (for data reception)"]
-            #[inline]
-            pub fn pos(&mut self) -> _POSW {
-                _POSW { w: self }
-            }
-            #[doc = "Bit 10 - Acknowledge enable"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 9 - Stop generation"]
-            #[inline]
-            pub fn stop(&mut self) -> _STOPW {
-                _STOPW { w: self }
-            }
-            #[doc = "Bit 8 - Start generation"]
-            #[inline]
-            pub fn start(&mut self) -> _STARTW {
-                _STARTW { w: self }
-            }
-            #[doc = "Bit 7 - Clock stretching disable (Slave mode)"]
-            #[inline]
-            pub fn nostretch(&mut self) -> _NOSTRETCHW {
-                _NOSTRETCHW { w: self }
-            }
-            #[doc = "Bit 6 - General call enable"]
-            #[inline]
-            pub fn engc(&mut self) -> _ENGCW {
-                _ENGCW { w: self }
-            }
-            #[doc = "Bit 5 - PEC enable"]
-            #[inline]
-            pub fn enpec(&mut self) -> _ENPECW {
-                _ENPECW { w: self }
-            }
-            #[doc = "Bit 4 - ARP enable"]
-            #[inline]
-            pub fn enarp(&mut self) -> _ENARPW {
-                _ENARPW { w: self }
-            }
-            #[doc = "Bit 3 - SMBus type"]
-            #[inline]
-            pub fn smbtype(&mut self) -> _SMBTYPEW {
-                _SMBTYPEW { w: self }
-            }
-            #[doc = "Bit 1 - SMBus mode"]
-            #[inline]
-            pub fn smbus(&mut self) -> _SMBUSW {
-                _SMBUSW { w: self }
-            }
-            #[doc = "Bit 0 - Peripheral enable"]
-            #[inline]
-            pub fn pe(&mut self) -> _PEW {
-                _PEW { w: self }
-            }
-        }
-    }
-    #[doc = "Control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct LASTR {
-            bits: bool,
-        }
-        impl LASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAENR {
-            bits: bool,
-        }
-        impl DMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ITBUFENR {
-            bits: bool,
-        }
-        impl ITBUFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ITEVTENR {
-            bits: bool,
-        }
-        impl ITEVTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ITERRENR {
-            bits: bool,
-        }
-        impl ITERRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FREQR {
-            bits: u8,
-        }
-        impl FREQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _LASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LASTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ITBUFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITBUFENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ITEVTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITEVTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ITERRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITERRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FREQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FREQW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x3f;
-                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 = "Bit 12 - DMA last transfer"]
-            #[inline]
-            pub fn last(&self) -> LASTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LASTR { bits }
-            }
-            #[doc = "Bit 11 - DMA requests enable"]
-            #[inline]
-            pub fn dmaen(&self) -> DMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAENR { bits }
-            }
-            #[doc = "Bit 10 - Buffer interrupt enable"]
-            #[inline]
-            pub fn itbufen(&self) -> ITBUFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ITBUFENR { bits }
-            }
-            #[doc = "Bit 9 - Event interrupt enable"]
-            #[inline]
-            pub fn itevten(&self) -> ITEVTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ITEVTENR { bits }
-            }
-            #[doc = "Bit 8 - Error interrupt enable"]
-            #[inline]
-            pub fn iterren(&self) -> ITERRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ITERRENR { bits }
-            }
-            #[doc = "Bits 0:5 - Peripheral clock frequency"]
-            #[inline]
-            pub fn freq(&self) -> FREQR {
-                let bits = {
-                    const MASK: u8 = 0x3f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FREQR { bits }
-            }
-        }
-        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 12 - DMA last transfer"]
-            #[inline]
-            pub fn last(&mut self) -> _LASTW {
-                _LASTW { w: self }
-            }
-            #[doc = "Bit 11 - DMA requests enable"]
-            #[inline]
-            pub fn dmaen(&mut self) -> _DMAENW {
-                _DMAENW { w: self }
-            }
-            #[doc = "Bit 10 - Buffer interrupt enable"]
-            #[inline]
-            pub fn itbufen(&mut self) -> _ITBUFENW {
-                _ITBUFENW { w: self }
-            }
-            #[doc = "Bit 9 - Event interrupt enable"]
-            #[inline]
-            pub fn itevten(&mut self) -> _ITEVTENW {
-                _ITEVTENW { w: self }
-            }
-            #[doc = "Bit 8 - Error interrupt enable"]
-            #[inline]
-            pub fn iterren(&mut self) -> _ITERRENW {
-                _ITERRENW { w: self }
-            }
-            #[doc = "Bits 0:5 - Peripheral clock frequency"]
-            #[inline]
-            pub fn freq(&mut self) -> _FREQW {
-                _FREQW { w: self }
-            }
-        }
-    }
-    #[doc = "Own address register 1"]
-    pub struct OAR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Own address register 1"]
-    pub mod oar1 {
-        #[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::OAR1 {
-            #[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 = r" Value of the field"]
-        pub struct ADDMODER {
-            bits: bool,
-        }
-        impl ADDMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADD10R {
-            bits: u8,
-        }
-        impl ADD10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADD7R {
-            bits: u8,
-        }
-        impl ADD7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADD0R {
-            bits: bool,
-        }
-        impl ADD0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ADDMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDMODEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADD10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADD10W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADD7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADD7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 1;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADD0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADD0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Addressing mode (slave mode)"]
-            #[inline]
-            pub fn addmode(&self) -> ADDMODER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADDMODER { bits }
-            }
-            #[doc = "Bits 8:9 - Interface address"]
-            #[inline]
-            pub fn add10(&self) -> ADD10R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADD10R { bits }
-            }
-            #[doc = "Bits 1:7 - Interface address"]
-            #[inline]
-            pub fn add7(&self) -> ADD7R {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADD7R { bits }
-            }
-            #[doc = "Bit 0 - Interface address"]
-            #[inline]
-            pub fn add0(&self) -> ADD0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADD0R { bits }
-            }
-        }
-        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 15 - Addressing mode (slave mode)"]
-            #[inline]
-            pub fn addmode(&mut self) -> _ADDMODEW {
-                _ADDMODEW { w: self }
-            }
-            #[doc = "Bits 8:9 - Interface address"]
-            #[inline]
-            pub fn add10(&mut self) -> _ADD10W {
-                _ADD10W { w: self }
-            }
-            #[doc = "Bits 1:7 - Interface address"]
-            #[inline]
-            pub fn add7(&mut self) -> _ADD7W {
-                _ADD7W { w: self }
-            }
-            #[doc = "Bit 0 - Interface address"]
-            #[inline]
-            pub fn add0(&mut self) -> _ADD0W {
-                _ADD0W { w: self }
-            }
-        }
-    }
-    #[doc = "Own address register 2"]
-    pub struct OAR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Own address register 2"]
-    pub mod oar2 {
-        #[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::OAR2 {
-            #[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 = r" Value of the field"]
-        pub struct ADD2R {
-            bits: u8,
-        }
-        impl ADD2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ENDUALR {
-            bits: bool,
-        }
-        impl ENDUALR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ADD2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADD2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 1;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ENDUALW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENDUALW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 1:7 - Interface address"]
-            #[inline]
-            pub fn add2(&self) -> ADD2R {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADD2R { bits }
-            }
-            #[doc = "Bit 0 - Dual addressing mode enable"]
-            #[inline]
-            pub fn endual(&self) -> ENDUALR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENDUALR { bits }
-            }
-        }
-        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 1:7 - Interface address"]
-            #[inline]
-            pub fn add2(&mut self) -> _ADD2W {
-                _ADD2W { w: self }
-            }
-            #[doc = "Bit 0 - Dual addressing mode enable"]
-            #[inline]
-            pub fn endual(&mut self) -> _ENDUALW {
-                _ENDUALW { w: self }
-            }
-        }
-    }
-    #[doc = "Data register"]
-    pub struct DR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Data register"]
-    pub mod dr {
-        #[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::DR {
-            #[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 = r" Value of the field"]
-        pub struct DRR {
-            bits: u8,
-        }
-        impl DRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - 8-bit data register"]
-            #[inline]
-            pub fn dr(&self) -> DRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DRR { bits }
-            }
-        }
-        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 0:7 - 8-bit data register"]
-            #[inline]
-            pub fn dr(&mut self) -> _DRW {
-                _DRW { w: self }
-            }
-        }
-    }
-    #[doc = "Status register 1"]
-    pub struct SR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Status register 1"]
-    pub mod sr1 {
-        #[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::SR1 {
-            #[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 = r" Value of the field"]
-        pub struct SMBALERTR {
-            bits: bool,
-        }
-        impl SMBALERTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIMEOUTR {
-            bits: bool,
-        }
-        impl TIMEOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PECERRR {
-            bits: bool,
-        }
-        impl PECERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVRR {
-            bits: bool,
-        }
-        impl OVRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AFR {
-            bits: bool,
-        }
-        impl AFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ARLOR {
-            bits: bool,
-        }
-        impl ARLOR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BERRR {
-            bits: bool,
-        }
-        impl BERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXER {
-            bits: bool,
-        }
-        impl TXER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXNER {
-            bits: bool,
-        }
-        impl RXNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STOPFR {
-            bits: bool,
-        }
-        impl STOPFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADD10R {
-            bits: bool,
-        }
-        impl ADD10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BTFR {
-            bits: bool,
-        }
-        impl BTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADDRR {
-            bits: bool,
-        }
-        impl ADDRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SBR {
-            bits: bool,
-        }
-        impl SBR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SMBALERTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMBALERTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIMEOUTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMEOUTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PECERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PECERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OVRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ARLOW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARLOW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - SMBus alert"]
-            #[inline]
-            pub fn smbalert(&self) -> SMBALERTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMBALERTR { bits }
-            }
-            #[doc = "Bit 14 - Timeout or Tlow error"]
-            #[inline]
-            pub fn timeout(&self) -> TIMEOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIMEOUTR { bits }
-            }
-            #[doc = "Bit 12 - PEC Error in reception"]
-            #[inline]
-            pub fn pecerr(&self) -> PECERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PECERRR { bits }
-            }
-            #[doc = "Bit 11 - Overrun/Underrun"]
-            #[inline]
-            pub fn ovr(&self) -> OVRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRR { bits }
-            }
-            #[doc = "Bit 10 - Acknowledge failure"]
-            #[inline]
-            pub fn af(&self) -> AFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AFR { bits }
-            }
-            #[doc = "Bit 9 - Arbitration lost (master mode)"]
-            #[inline]
-            pub fn arlo(&self) -> ARLOR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARLOR { bits }
-            }
-            #[doc = "Bit 8 - Bus error"]
-            #[inline]
-            pub fn berr(&self) -> BERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BERRR { bits }
-            }
-            #[doc = "Bit 7 - Data register empty (transmitters)"]
-            #[inline]
-            pub fn tx_e(&self) -> TXER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXER { bits }
-            }
-            #[doc = "Bit 6 - Data register not empty (receivers)"]
-            #[inline]
-            pub fn rx_ne(&self) -> RXNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXNER { bits }
-            }
-            #[doc = "Bit 4 - Stop detection (slave mode)"]
-            #[inline]
-            pub fn stopf(&self) -> STOPFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STOPFR { bits }
-            }
-            #[doc = "Bit 3 - 10-bit header sent (Master mode)"]
-            #[inline]
-            pub fn add10(&self) -> ADD10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADD10R { bits }
-            }
-            #[doc = "Bit 2 - Byte transfer finished"]
-            #[inline]
-            pub fn btf(&self) -> BTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BTFR { bits }
-            }
-            #[doc = "Bit 1 - Address sent (master mode)/matched (slave mode)"]
-            #[inline]
-            pub fn addr(&self) -> ADDRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADDRR { bits }
-            }
-            #[doc = "Bit 0 - Start bit (Master mode)"]
-            #[inline]
-            pub fn sb(&self) -> SBR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SBR { bits }
-            }
-        }
-        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 15 - SMBus alert"]
-            #[inline]
-            pub fn smbalert(&mut self) -> _SMBALERTW {
-                _SMBALERTW { w: self }
-            }
-            #[doc = "Bit 14 - Timeout or Tlow error"]
-            #[inline]
-            pub fn timeout(&mut self) -> _TIMEOUTW {
-                _TIMEOUTW { w: self }
-            }
-            #[doc = "Bit 12 - PEC Error in reception"]
-            #[inline]
-            pub fn pecerr(&mut self) -> _PECERRW {
-                _PECERRW { w: self }
-            }
-            #[doc = "Bit 11 - Overrun/Underrun"]
-            #[inline]
-            pub fn ovr(&mut self) -> _OVRW {
-                _OVRW { w: self }
-            }
-            #[doc = "Bit 10 - Acknowledge failure"]
-            #[inline]
-            pub fn af(&mut self) -> _AFW {
-                _AFW { w: self }
-            }
-            #[doc = "Bit 9 - Arbitration lost (master mode)"]
-            #[inline]
-            pub fn arlo(&mut self) -> _ARLOW {
-                _ARLOW { w: self }
-            }
-            #[doc = "Bit 8 - Bus error"]
-            #[inline]
-            pub fn berr(&mut self) -> _BERRW {
-                _BERRW { w: self }
-            }
-        }
-    }
-    #[doc = "Status register 2"]
-    pub struct SR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Status register 2"]
-    pub mod sr2 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::SR2 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PECR {
-            bits: u8,
-        }
-        impl PECR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DUALFR {
-            bits: bool,
-        }
-        impl DUALFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SMBHOSTR {
-            bits: bool,
-        }
-        impl SMBHOSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SMBDEFAULTR {
-            bits: bool,
-        }
-        impl SMBDEFAULTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GENCALLR {
-            bits: bool,
-        }
-        impl GENCALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TRAR {
-            bits: bool,
-        }
-        impl TRAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BUSYR {
-            bits: bool,
-        }
-        impl BUSYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MSLR {
-            bits: bool,
-        }
-        impl MSLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:15 - acket error checking register"]
-            #[inline]
-            pub fn pec(&self) -> PECR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PECR { bits }
-            }
-            #[doc = "Bit 7 - Dual flag (Slave mode)"]
-            #[inline]
-            pub fn dualf(&self) -> DUALFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DUALFR { bits }
-            }
-            #[doc = "Bit 6 - SMBus host header (Slave mode)"]
-            #[inline]
-            pub fn smbhost(&self) -> SMBHOSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMBHOSTR { bits }
-            }
-            #[doc = "Bit 5 - SMBus device default address (Slave mode)"]
-            #[inline]
-            pub fn smbdefault(&self) -> SMBDEFAULTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMBDEFAULTR { bits }
-            }
-            #[doc = "Bit 4 - General call address (Slave mode)"]
-            #[inline]
-            pub fn gencall(&self) -> GENCALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GENCALLR { bits }
-            }
-            #[doc = "Bit 2 - Transmitter/receiver"]
-            #[inline]
-            pub fn tra(&self) -> TRAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TRAR { bits }
-            }
-            #[doc = "Bit 1 - Bus busy"]
-            #[inline]
-            pub fn busy(&self) -> BUSYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BUSYR { bits }
-            }
-            #[doc = "Bit 0 - Master/slave"]
-            #[inline]
-            pub fn msl(&self) -> MSLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSLR { bits }
-            }
-        }
-    }
-    #[doc = "Clock control register"]
-    pub struct CCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Clock control register"]
-    pub mod ccr {
-        #[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::CCR {
-            #[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 = r" Value of the field"]
-        pub struct F_SR {
-            bits: bool,
-        }
-        impl F_SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DUTYR {
-            bits: bool,
-        }
-        impl DUTYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCRR {
-            bits: u16,
-        }
-        impl CCRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _F_SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _F_SW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DUTYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DUTYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CCRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 = "Bit 15 - I2C master mode selection"]
-            #[inline]
-            pub fn f_s(&self) -> F_SR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                F_SR { bits }
-            }
-            #[doc = "Bit 14 - Fast mode duty cycle"]
-            #[inline]
-            pub fn duty(&self) -> DUTYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DUTYR { bits }
-            }
-            #[doc = "Bits 0:11 - Clock control register in Fast/Standard mode (Master mode)"]
-            #[inline]
-            pub fn ccr(&self) -> CCRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCRR { bits }
-            }
-        }
-        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 15 - I2C master mode selection"]
-            #[inline]
-            pub fn f_s(&mut self) -> _F_SW {
-                _F_SW { w: self }
-            }
-            #[doc = "Bit 14 - Fast mode duty cycle"]
-            #[inline]
-            pub fn duty(&mut self) -> _DUTYW {
-                _DUTYW { w: self }
-            }
-            #[doc = "Bits 0:11 - Clock control register in Fast/Standard mode (Master mode)"]
-            #[inline]
-            pub fn ccr(&mut self) -> _CCRW {
-                _CCRW { w: self }
-            }
-        }
-    }
-    #[doc = "TRISE register"]
-    pub struct TRISE {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "TRISE register"]
-    pub mod trise {
-        #[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::TRISE {
-            #[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 = r" Value of the field"]
-        pub struct TRISER {
-            bits: u8,
-        }
-        impl TRISER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TRISEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRISEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x3f;
-                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 0:5 - Maximum rise time in Fast/Standard mode (Master mode)"]
-            #[inline]
-            pub fn trise(&self) -> TRISER {
-                let bits = {
-                    const MASK: u8 = 0x3f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TRISER { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x02 }
-            }
-            #[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 0:5 - Maximum rise time in Fast/Standard mode (Master mode)"]
-            #[inline]
-            pub fn trise(&mut self) -> _TRISEW {
-                _TRISEW { w: self }
-            }
-        }
-    }
-}
-#[doc = "I2C2"]
-pub struct I2C2 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for I2C2 {}
-impl I2C2 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2c3::RegisterBlock {
-        0x4000_5800 as *const _
-    }
-}
-impl Deref for I2C2 {
-    type Target = i2c3::RegisterBlock;
-    fn deref(&self) -> &i2c3::RegisterBlock {
-        unsafe { &*I2C2::ptr() }
-    }
-}
-#[doc = "I2C1"]
-pub struct I2C1 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for I2C1 {}
-impl I2C1 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2c3::RegisterBlock {
-        0x4000_5400 as *const _
-    }
-}
-impl Deref for I2C1 {
-    type Target = i2c3::RegisterBlock;
-    fn deref(&self) -> &i2c3::RegisterBlock {
-        unsafe { &*I2C1::ptr() }
-    }
-}
-#[doc = "Serial peripheral interface"]
-pub struct I2S2EXT {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for I2S2EXT {}
-impl I2S2EXT {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2s2ext::RegisterBlock {
-        0x4000_3400 as *const _
-    }
-}
-impl Deref for I2S2EXT {
-    type Target = i2s2ext::RegisterBlock;
-    fn deref(&self) -> &i2s2ext::RegisterBlock {
-        unsafe { &*I2S2EXT::ptr() }
-    }
-}
-#[doc = "Serial peripheral interface"]
-pub mod i2s2ext {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x08 - status register"]
-        pub sr: SR,
-        #[doc = "0x0c - data register"]
-        pub dr: DR,
-        #[doc = "0x10 - CRC polynomial register"]
-        pub crcpr: CRCPR,
-        #[doc = "0x14 - RX CRC register"]
-        pub rxcrcr: RXCRCR,
-        #[doc = "0x18 - TX CRC register"]
-        pub txcrcr: TXCRCR,
-        #[doc = "0x1c - I2S configuration register"]
-        pub i2scfgr: I2SCFGR,
-        #[doc = "0x20 - I2S prescaler register"]
-        pub i2spr: I2SPR,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct BIDIMODER {
-            bits: bool,
-        }
-        impl BIDIMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BIDIOER {
-            bits: bool,
-        }
-        impl BIDIOER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CRCENR {
-            bits: bool,
-        }
-        impl CRCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CRCNEXTR {
-            bits: bool,
-        }
-        impl CRCNEXTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFFR {
-            bits: bool,
-        }
-        impl DFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXONLYR {
-            bits: bool,
-        }
-        impl RXONLYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SSMR {
-            bits: bool,
-        }
-        impl SSMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SSIR {
-            bits: bool,
-        }
-        impl SSIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSBFIRSTR {
-            bits: bool,
-        }
-        impl LSBFIRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPER {
-            bits: bool,
-        }
-        impl SPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BRR {
-            bits: u8,
-        }
-        impl BRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MSTRR {
-            bits: bool,
-        }
-        impl MSTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CPOLR {
-            bits: bool,
-        }
-        impl CPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CPHAR {
-            bits: bool,
-        }
-        impl CPHAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _BIDIMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BIDIMODEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BIDIOEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BIDIOEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CRCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CRCNEXTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRCNEXTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXONLYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXONLYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SSMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SSMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SSIW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SSIW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSBFIRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSBFIRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSTRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSTRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CPHAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CPHAW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 15 - Bidirectional data mode enable"]
-            #[inline]
-            pub fn bidimode(&self) -> BIDIMODER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BIDIMODER { bits }
-            }
-            #[doc = "Bit 14 - Output enable in bidirectional mode"]
-            #[inline]
-            pub fn bidioe(&self) -> BIDIOER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BIDIOER { bits }
-            }
-            #[doc = "Bit 13 - Hardware CRC calculation enable"]
-            #[inline]
-            pub fn crcen(&self) -> CRCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CRCENR { bits }
-            }
-            #[doc = "Bit 12 - CRC transfer next"]
-            #[inline]
-            pub fn crcnext(&self) -> CRCNEXTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CRCNEXTR { bits }
-            }
-            #[doc = "Bit 11 - Data frame format"]
-            #[inline]
-            pub fn dff(&self) -> DFFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFFR { bits }
-            }
-            #[doc = "Bit 10 - Receive only"]
-            #[inline]
-            pub fn rxonly(&self) -> RXONLYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXONLYR { bits }
-            }
-            #[doc = "Bit 9 - Software slave management"]
-            #[inline]
-            pub fn ssm(&self) -> SSMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SSMR { bits }
-            }
-            #[doc = "Bit 8 - Internal slave select"]
-            #[inline]
-            pub fn ssi(&self) -> SSIR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SSIR { bits }
-            }
-            #[doc = "Bit 7 - Frame format"]
-            #[inline]
-            pub fn lsbfirst(&self) -> LSBFIRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSBFIRSTR { bits }
-            }
-            #[doc = "Bit 6 - SPI enable"]
-            #[inline]
-            pub fn spe(&self) -> SPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SPER { bits }
-            }
-            #[doc = "Bits 3:5 - Baud rate control"]
-            #[inline]
-            pub fn br(&self) -> BRR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BRR { bits }
-            }
-            #[doc = "Bit 2 - Master selection"]
-            #[inline]
-            pub fn mstr(&self) -> MSTRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSTRR { bits }
-            }
-            #[doc = "Bit 1 - Clock polarity"]
-            #[inline]
-            pub fn cpol(&self) -> CPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CPOLR { bits }
-            }
-            #[doc = "Bit 0 - Clock phase"]
-            #[inline]
-            pub fn cpha(&self) -> CPHAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CPHAR { bits }
-            }
-        }
-        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 15 - Bidirectional data mode enable"]
-            #[inline]
-            pub fn bidimode(&mut self) -> _BIDIMODEW {
-                _BIDIMODEW { w: self }
-            }
-            #[doc = "Bit 14 - Output enable in bidirectional mode"]
-            #[inline]
-            pub fn bidioe(&mut self) -> _BIDIOEW {
-                _BIDIOEW { w: self }
-            }
-            #[doc = "Bit 13 - Hardware CRC calculation enable"]
-            #[inline]
-            pub fn crcen(&mut self) -> _CRCENW {
-                _CRCENW { w: self }
-            }
-            #[doc = "Bit 12 - CRC transfer next"]
-            #[inline]
-            pub fn crcnext(&mut self) -> _CRCNEXTW {
-                _CRCNEXTW { w: self }
-            }
-            #[doc = "Bit 11 - Data frame format"]
-            #[inline]
-            pub fn dff(&mut self) -> _DFFW {
-                _DFFW { w: self }
-            }
-            #[doc = "Bit 10 - Receive only"]
-            #[inline]
-            pub fn rxonly(&mut self) -> _RXONLYW {
-                _RXONLYW { w: self }
-            }
-            #[doc = "Bit 9 - Software slave management"]
-            #[inline]
-            pub fn ssm(&mut self) -> _SSMW {
-                _SSMW { w: self }
-            }
-            #[doc = "Bit 8 - Internal slave select"]
-            #[inline]
-            pub fn ssi(&mut self) -> _SSIW {
-                _SSIW { w: self }
-            }
-            #[doc = "Bit 7 - Frame format"]
-            #[inline]
-            pub fn lsbfirst(&mut self) -> _LSBFIRSTW {
-                _LSBFIRSTW { w: self }
-            }
-            #[doc = "Bit 6 - SPI enable"]
-            #[inline]
-            pub fn spe(&mut self) -> _SPEW {
-                _SPEW { w: self }
-            }
-            #[doc = "Bits 3:5 - Baud rate control"]
-            #[inline]
-            pub fn br(&mut self) -> _BRW {
-                _BRW { w: self }
-            }
-            #[doc = "Bit 2 - Master selection"]
-            #[inline]
-            pub fn mstr(&mut self) -> _MSTRW {
-                _MSTRW { w: self }
-            }
-            #[doc = "Bit 1 - Clock polarity"]
-            #[inline]
-            pub fn cpol(&mut self) -> _CPOLW {
-                _CPOLW { w: self }
-            }
-            #[doc = "Bit 0 - Clock phase"]
-            #[inline]
-            pub fn cpha(&mut self) -> _CPHAW {
-                _CPHAW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct TXEIER {
-            bits: bool,
-        }
-        impl TXEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXNEIER {
-            bits: bool,
-        }
-        impl RXNEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ERRIER {
-            bits: bool,
-        }
-        impl ERRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRFR {
-            bits: bool,
-        }
-        impl FRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SSOER {
-            bits: bool,
-        }
-        impl SSOER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXDMAENR {
-            bits: bool,
-        }
-        impl TXDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXDMAENR {
-            bits: bool,
-        }
-        impl RXDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TXEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXNEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXNEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ERRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ERRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SSOEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SSOEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXDMAENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - Tx buffer empty interrupt enable"]
-            #[inline]
-            pub fn txeie(&self) -> TXEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXEIER { bits }
-            }
-            #[doc = "Bit 6 - RX buffer not empty interrupt enable"]
-            #[inline]
-            pub fn rxneie(&self) -> RXNEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXNEIER { bits }
-            }
-            #[doc = "Bit 5 - Error interrupt enable"]
-            #[inline]
-            pub fn errie(&self) -> ERRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ERRIER { bits }
-            }
-            #[doc = "Bit 4 - Frame format"]
-            #[inline]
-            pub fn frf(&self) -> FRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRFR { bits }
-            }
-            #[doc = "Bit 2 - SS output enable"]
-            #[inline]
-            pub fn ssoe(&self) -> SSOER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SSOER { bits }
-            }
-            #[doc = "Bit 1 - Tx buffer DMA enable"]
-            #[inline]
-            pub fn txdmaen(&self) -> TXDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXDMAENR { bits }
-            }
-            #[doc = "Bit 0 - Rx buffer DMA enable"]
-            #[inline]
-            pub fn rxdmaen(&self) -> RXDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXDMAENR { bits }
-            }
-        }
-        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 7 - Tx buffer empty interrupt enable"]
-            #[inline]
-            pub fn txeie(&mut self) -> _TXEIEW {
-                _TXEIEW { w: self }
-            }
-            #[doc = "Bit 6 - RX buffer not empty interrupt enable"]
-            #[inline]
-            pub fn rxneie(&mut self) -> _RXNEIEW {
-                _RXNEIEW { w: self }
-            }
-            #[doc = "Bit 5 - Error interrupt enable"]
-            #[inline]
-            pub fn errie(&mut self) -> _ERRIEW {
-                _ERRIEW { w: self }
-            }
-            #[doc = "Bit 4 - Frame format"]
-            #[inline]
-            pub fn frf(&mut self) -> _FRFW {
-                _FRFW { w: self }
-            }
-            #[doc = "Bit 2 - SS output enable"]
-            #[inline]
-            pub fn ssoe(&mut self) -> _SSOEW {
-                _SSOEW { w: self }
-            }
-            #[doc = "Bit 1 - Tx buffer DMA enable"]
-            #[inline]
-            pub fn txdmaen(&mut self) -> _TXDMAENW {
-                _TXDMAENW { w: self }
-            }
-            #[doc = "Bit 0 - Rx buffer DMA enable"]
-            #[inline]
-            pub fn rxdmaen(&mut self) -> _RXDMAENW {
-                _RXDMAENW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct TIFRFER {
-            bits: bool,
-        }
-        impl TIFRFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BSYR {
-            bits: bool,
-        }
-        impl BSYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVRR {
-            bits: bool,
-        }
-        impl OVRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MODFR {
-            bits: bool,
-        }
-        impl MODFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CRCERRR {
-            bits: bool,
-        }
-        impl CRCERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDRR {
-            bits: bool,
-        }
-        impl UDRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHSIDER {
-            bits: bool,
-        }
-        impl CHSIDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXER {
-            bits: bool,
-        }
-        impl TXER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXNER {
-            bits: bool,
-        }
-        impl RXNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CRCERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRCERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 8 - TI frame format error"]
-            #[inline]
-            pub fn tifrfe(&self) -> TIFRFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIFRFER { bits }
-            }
-            #[doc = "Bit 7 - Busy flag"]
-            #[inline]
-            pub fn bsy(&self) -> BSYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BSYR { bits }
-            }
-            #[doc = "Bit 6 - Overrun flag"]
-            #[inline]
-            pub fn ovr(&self) -> OVRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRR { bits }
-            }
-            #[doc = "Bit 5 - Mode fault"]
-            #[inline]
-            pub fn modf(&self) -> MODFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MODFR { bits }
-            }
-            #[doc = "Bit 4 - CRC error flag"]
-            #[inline]
-            pub fn crcerr(&self) -> CRCERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CRCERRR { bits }
-            }
-            #[doc = "Bit 3 - Underrun flag"]
-            #[inline]
-            pub fn udr(&self) -> UDRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDRR { bits }
-            }
-            #[doc = "Bit 2 - Channel side"]
-            #[inline]
-            pub fn chside(&self) -> CHSIDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHSIDER { bits }
-            }
-            #[doc = "Bit 1 - Transmit buffer empty"]
-            #[inline]
-            pub fn txe(&self) -> TXER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXER { bits }
-            }
-            #[doc = "Bit 0 - Receive buffer not empty"]
-            #[inline]
-            pub fn rxne(&self) -> RXNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXNER { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x02 }
-            }
-            #[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 4 - CRC error flag"]
-            #[inline]
-            pub fn crcerr(&mut self) -> _CRCERRW {
-                _CRCERRW { w: self }
-            }
-        }
-    }
-    #[doc = "data register"]
-    pub struct DR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register"]
-    pub mod dr {
-        #[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::DR {
-            #[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 = r" Value of the field"]
-        pub struct DRR {
-            bits: u16,
-        }
-        impl DRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Data register"]
-            #[inline]
-            pub fn dr(&self) -> DRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DRR { bits }
-            }
-        }
-        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 0:15 - Data register"]
-            #[inline]
-            pub fn dr(&mut self) -> _DRW {
-                _DRW { w: self }
-            }
-        }
-    }
-    #[doc = "CRC polynomial register"]
-    pub struct CRCPR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CRC polynomial register"]
-    pub mod crcpr {
-        #[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::CRCPR {
-            #[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 = r" Value of the field"]
-        pub struct CRCPOLYR {
-            bits: u16,
-        }
-        impl CRCPOLYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CRCPOLYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CRCPOLYW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - CRC polynomial register"]
-            #[inline]
-            pub fn crcpoly(&self) -> CRCPOLYR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CRCPOLYR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x07 }
-            }
-            #[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 0:15 - CRC polynomial register"]
-            #[inline]
-            pub fn crcpoly(&mut self) -> _CRCPOLYW {
-                _CRCPOLYW { w: self }
-            }
-        }
-    }
-    #[doc = "RX CRC register"]
-    pub struct RXCRCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "RX CRC register"]
-    pub mod rxcrcr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RXCRCR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RXCRCR {
-            bits: u16,
-        }
-        impl RXCRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Rx CRC register"]
-            #[inline]
-            pub fn rx_crc(&self) -> RXCRCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                RXCRCR { bits }
-            }
-        }
-    }
-    #[doc = "TX CRC register"]
-    pub struct TXCRCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "TX CRC register"]
-    pub mod txcrcr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::TXCRCR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TXCRCR {
-            bits: u16,
-        }
-        impl TXCRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Tx CRC register"]
-            #[inline]
-            pub fn tx_crc(&self) -> TXCRCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TXCRCR { bits }
-            }
-        }
-    }
-    #[doc = "I2S configuration register"]
-    pub struct I2SCFGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "I2S configuration register"]
-    pub mod i2scfgr {
-        #[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::I2SCFGR {
-            #[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 = r" Value of the field"]
-        pub struct I2SMODR {
-            bits: bool,
-        }
-        impl I2SMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2SER {
-            bits: bool,
-        }
-        impl I2SER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2SCFGR {
-            bits: u8,
-        }
-        impl I2SCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PCMSYNCR {
-            bits: bool,
-        }
-        impl PCMSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2SSTDR {
-            bits: u8,
-        }
-        impl I2SSTDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKPOLR {
-            bits: bool,
-        }
-        impl CKPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DATLENR {
-            bits: u8,
-        }
-        impl DATLENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHLENR {
-            bits: bool,
-        }
-        impl CHLENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _I2SMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2SMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2SEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2SEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2SCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2SCFGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PCMSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PCMSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2SSTDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2SSTDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DATLENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 1;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHLENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHLENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 11 - I2S mode selection"]
-            #[inline]
-            pub fn i2smod(&self) -> I2SMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2SMODR { bits }
-            }
-            #[doc = "Bit 10 - I2S Enable"]
-            #[inline]
-            pub fn i2se(&self) -> I2SER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                I2SER { bits }
-            }
-            #[doc = "Bits 8:9 - I2S configuration mode"]
-            #[inline]
-            pub fn i2scfg(&self) -> I2SCFGR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                I2SCFGR { bits }
-            }
-            #[doc = "Bit 7 - PCM frame synchronization"]
-            #[inline]
-            pub fn pcmsync(&self) -> PCMSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PCMSYNCR { bits }
-            }
-            #[doc = "Bits 4:5 - I2S standard selection"]
-            #[inline]
-            pub fn i2sstd(&self) -> I2SSTDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                I2SSTDR { bits }
-            }
-            #[doc = "Bit 3 - Steady state clock polarity"]
-            #[inline]
-            pub fn ckpol(&self) -> CKPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKPOLR { bits }
-            }
-            #[doc = "Bits 1:2 - Data length to be transferred"]
-            #[inline]
-            pub fn datlen(&self) -> DATLENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLENR { bits }
-            }
-            #[doc = "Bit 0 - Channel length (number of bits per audio channel)"]
-            #[inline]
-            pub fn chlen(&self) -> CHLENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHLENR { bits }
-            }
-        }
-        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 11 - I2S mode selection"]
-            #[inline]
-            pub fn i2smod(&mut self) -> _I2SMODW {
-                _I2SMODW { w: self }
-            }
-            #[doc = "Bit 10 - I2S Enable"]
-            #[inline]
-            pub fn i2se(&mut self) -> _I2SEW {
-                _I2SEW { w: self }
-            }
-            #[doc = "Bits 8:9 - I2S configuration mode"]
-            #[inline]
-            pub fn i2scfg(&mut self) -> _I2SCFGW {
-                _I2SCFGW { w: self }
-            }
-            #[doc = "Bit 7 - PCM frame synchronization"]
-            #[inline]
-            pub fn pcmsync(&mut self) -> _PCMSYNCW {
-                _PCMSYNCW { w: self }
-            }
-            #[doc = "Bits 4:5 - I2S standard selection"]
-            #[inline]
-            pub fn i2sstd(&mut self) -> _I2SSTDW {
-                _I2SSTDW { w: self }
-            }
-            #[doc = "Bit 3 - Steady state clock polarity"]
-            #[inline]
-            pub fn ckpol(&mut self) -> _CKPOLW {
-                _CKPOLW { w: self }
-            }
-            #[doc = "Bits 1:2 - Data length to be transferred"]
-            #[inline]
-            pub fn datlen(&mut self) -> _DATLENW {
-                _DATLENW { w: self }
-            }
-            #[doc = "Bit 0 - Channel length (number of bits per audio channel)"]
-            #[inline]
-            pub fn chlen(&mut self) -> _CHLENW {
-                _CHLENW { w: self }
-            }
-        }
-    }
-    #[doc = "I2S prescaler register"]
-    pub struct I2SPR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "I2S prescaler register"]
-    pub mod i2spr {
-        #[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::I2SPR {
-            #[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 = r" Value of the field"]
-        pub struct MCKOER {
-            bits: bool,
-        }
-        impl MCKOER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ODDR {
-            bits: bool,
-        }
-        impl ODDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct I2SDIVR {
-            bits: u8,
-        }
-        impl I2SDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCKOEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCKOEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ODDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _I2SDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _I2SDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 = "Bit 9 - Master clock output enable"]
-            #[inline]
-            pub fn mckoe(&self) -> MCKOER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MCKOER { bits }
-            }
-            #[doc = "Bit 8 - Odd factor for the prescaler"]
-            #[inline]
-            pub fn odd(&self) -> ODDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDR { bits }
-            }
-            #[doc = "Bits 0:7 - I2S Linear prescaler"]
-            #[inline]
-            pub fn i2sdiv(&self) -> I2SDIVR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                I2SDIVR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0a }
-            }
-            #[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 9 - Master clock output enable"]
-            #[inline]
-            pub fn mckoe(&mut self) -> _MCKOEW {
-                _MCKOEW { w: self }
-            }
-            #[doc = "Bit 8 - Odd factor for the prescaler"]
-            #[inline]
-            pub fn odd(&mut self) -> _ODDW {
-                _ODDW { w: self }
-            }
-            #[doc = "Bits 0:7 - I2S Linear prescaler"]
-            #[inline]
-            pub fn i2sdiv(&mut self) -> _I2SDIVW {
-                _I2SDIVW { w: self }
-            }
-        }
-    }
-}
-#[doc = "I2S3ext"]
-pub struct I2S3EXT {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for I2S3EXT {}
-impl I2S3EXT {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2s2ext::RegisterBlock {
-        0x4000_4000 as *const _
-    }
-}
-impl Deref for I2S3EXT {
-    type Target = i2s2ext::RegisterBlock;
-    fn deref(&self) -> &i2s2ext::RegisterBlock {
-        unsafe { &*I2S3EXT::ptr() }
-    }
-}
-#[doc = "SPI1"]
-pub struct SPI1 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for SPI1 {}
-impl SPI1 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2s2ext::RegisterBlock {
-        0x4001_3000 as *const _
-    }
-}
-impl Deref for SPI1 {
-    type Target = i2s2ext::RegisterBlock;
-    fn deref(&self) -> &i2s2ext::RegisterBlock {
-        unsafe { &*SPI1::ptr() }
-    }
-}
-#[doc = "SPI2"]
-pub struct SPI2 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for SPI2 {}
-impl SPI2 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2s2ext::RegisterBlock {
-        0x4000_3800 as *const _
-    }
-}
-impl Deref for SPI2 {
-    type Target = i2s2ext::RegisterBlock;
-    fn deref(&self) -> &i2s2ext::RegisterBlock {
-        unsafe { &*SPI2::ptr() }
-    }
-}
-#[doc = "SPI3"]
-pub struct SPI3 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for SPI3 {}
-impl SPI3 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2s2ext::RegisterBlock {
-        0x4000_3c00 as *const _
-    }
-}
-impl Deref for SPI3 {
-    type Target = i2s2ext::RegisterBlock;
-    fn deref(&self) -> &i2s2ext::RegisterBlock {
-        unsafe { &*SPI3::ptr() }
-    }
-}
-#[doc = "SPI4"]
-pub struct SPI4 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for SPI4 {}
-impl SPI4 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2s2ext::RegisterBlock {
-        0x4001_3400 as *const _
-    }
-}
-impl Deref for SPI4 {
-    type Target = i2s2ext::RegisterBlock;
-    fn deref(&self) -> &i2s2ext::RegisterBlock {
-        unsafe { &*SPI4::ptr() }
-    }
-}
-#[doc = "SPI5"]
-pub struct SPI5 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for SPI5 {}
-impl SPI5 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2s2ext::RegisterBlock {
-        0x4001_5000 as *const _
-    }
-}
-impl Deref for SPI5 {
-    type Target = i2s2ext::RegisterBlock;
-    fn deref(&self) -> &i2s2ext::RegisterBlock {
-        unsafe { &*SPI5::ptr() }
-    }
-}
-#[doc = "SPI6"]
-pub struct SPI6 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for SPI6 {}
-impl SPI6 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const i2s2ext::RegisterBlock {
-        0x4001_5400 as *const _
-    }
-}
-impl Deref for SPI6 {
-    type Target = i2s2ext::RegisterBlock;
-    fn deref(&self) -> &i2s2ext::RegisterBlock {
-        unsafe { &*SPI6::ptr() }
-    }
-}
-#[doc = "Digital filter for sigma delta modulators"]
-pub struct DFSDM1 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for DFSDM1 {}
-impl DFSDM1 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const dfsdm1::RegisterBlock {
-        0x4001_6000 as *const _
-    }
-}
-impl Deref for DFSDM1 {
-    type Target = dfsdm1::RegisterBlock;
-    fn deref(&self) -> &dfsdm1::RegisterBlock {
-        unsafe { &*DFSDM1::ptr() }
-    }
-}
-#[doc = "Digital filter for sigma delta modulators"]
-pub mod dfsdm1 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - channel configuration y register"]
-        pub ch0cfgr1: CH0CFGR1,
-        #[doc = "0x04 - channel configuration y register"]
-        pub ch0cfgr2: CH0CFGR2,
-        #[doc = "0x08 - analog watchdog and short-circuit detector register"]
-        pub ch0awscdr: CH0AWSCDR,
-        #[doc = "0x0c - channel watchdog filter data register"]
-        pub ch0wdatr: CH0WDATR,
-        #[doc = "0x10 - channel data input register"]
-        pub ch0datinr: CH0DATINR,
-        _reserved0: [u8; 12usize],
-        #[doc = "0x20 - CHCFG1R1"]
-        pub ch1cfgr1: CH1CFGR1,
-        #[doc = "0x24 - CHCFG1R2"]
-        pub ch1cfgr2: CH1CFGR2,
-        #[doc = "0x28 - AWSCD1R"]
-        pub ch1awscdr: CH1AWSCDR,
-        #[doc = "0x2c - CHWDAT1R"]
-        pub ch1wdatr: CH1WDATR,
-        #[doc = "0x30 - CHDATIN1R"]
-        pub ch1datinr: CH1DATINR,
-        _reserved1: [u8; 12usize],
-        #[doc = "0x40 - CHCFG2R1"]
-        pub ch2cfgr1: CH2CFGR1,
-        #[doc = "0x44 - CHCFG2R2"]
-        pub ch2cfgr2: CH2CFGR2,
-        #[doc = "0x48 - AWSCD2R"]
-        pub ch2awscdr: CH2AWSCDR,
-        #[doc = "0x4c - CHWDAT2R"]
-        pub ch2wdatr: CH2WDATR,
-        #[doc = "0x50 - CHDATIN2R"]
-        pub ch2datinr: CH2DATINR,
-        _reserved2: [u8; 12usize],
-        #[doc = "0x60 - CHCFG3R1"]
-        pub ch3cfgr1: CH3CFGR1,
-        #[doc = "0x64 - CHCFG3R2"]
-        pub ch3cfgr2: CH3CFGR2,
-        #[doc = "0x68 - AWSCD3R"]
-        pub ch3awscdr: CH3AWSCDR,
-        #[doc = "0x6c - CHWDAT3R"]
-        pub ch3wdatr: CH3WDATR,
-        #[doc = "0x70 - CHDATIN3R"]
-        pub ch3datinr: CH3DATINR,
-        _reserved3: [u8; 12usize],
-        #[doc = "0x80 - CHCFG4R1"]
-        pub ch4cfgr1: CH4CFGR1,
-        #[doc = "0x84 - CHCFG4R2"]
-        pub ch4cfgr2: CH4CFGR2,
-        #[doc = "0x88 - AWSCD4R"]
-        pub ch4awscdr: CH4AWSCDR,
-        #[doc = "0x8c - CHWDAT4R"]
-        pub ch4wdatr: CH4WDATR,
-        #[doc = "0x90 - CHDATIN4R"]
-        pub ch4datinr: CH4DATINR,
-        _reserved4: [u8; 12usize],
-        #[doc = "0xa0 - CHCFG5R1"]
-        pub ch5cfgr1: CH5CFGR1,
-        #[doc = "0xa4 - CHCFG5R2"]
-        pub ch5cfgr2: CH5CFGR2,
-        #[doc = "0xa8 - AWSCD5R"]
-        pub ch5awscdr: CH5AWSCDR,
-        #[doc = "0xac - CHWDAT5R"]
-        pub ch5wdatr: CH5WDATR,
-        #[doc = "0xb0 - CHDATIN5R"]
-        pub ch5datinr: CH5DATINR,
-        _reserved5: [u8; 12usize],
-        #[doc = "0xc0 - CHCFG6R1"]
-        pub ch6cfgr1: CH6CFGR1,
-        #[doc = "0xc4 - CHCFG6R2"]
-        pub ch6cfgr2: CH6CFGR2,
-        #[doc = "0xc8 - AWSCD6R"]
-        pub ch6awscdr: CH6AWSCDR,
-        #[doc = "0xcc - CHWDAT6R"]
-        pub ch6wdatr: CH6WDATR,
-        #[doc = "0xd0 - CHDATIN6R"]
-        pub ch6datinr: CH6DATINR,
-        _reserved6: [u8; 12usize],
-        #[doc = "0xe0 - CHCFG7R1"]
-        pub ch7cfgr1: CH7CFGR1,
-        #[doc = "0xe4 - CHCFG7R2"]
-        pub ch7cfgr2: CH7CFGR2,
-        #[doc = "0xe8 - AWSCD7R"]
-        pub ch7awscdr: CH7AWSCDR,
-        #[doc = "0xec - CHWDAT7R"]
-        pub ch7wdatr: CH7WDATR,
-        #[doc = "0xf0 - CHDATIN7R"]
-        pub ch7datinr: CH7DATINR,
-        _reserved7: [u8; 12usize],
-        #[doc = "0x100 - control register 1"]
-        pub flt0cr1: FLT0CR1,
-        #[doc = "0x104 - control register 2"]
-        pub flt0cr2: FLT0CR2,
-        #[doc = "0x108 - interrupt and status register"]
-        pub flt0isr: FLT0ISR,
-        #[doc = "0x10c - interrupt flag clear register"]
-        pub flt0icr: FLT0ICR,
-        #[doc = "0x110 - injected channel group selection register"]
-        pub flt0jchgr: FLT0JCHGR,
-        #[doc = "0x114 - filter control register"]
-        pub flt0fcr: FLT0FCR,
-        #[doc = "0x118 - data register for injected group"]
-        pub flt0jdatar: FLT0JDATAR,
-        #[doc = "0x11c - data register for the regular channel"]
-        pub flt0rdatar: FLT0RDATAR,
-        #[doc = "0x120 - analog watchdog high threshold register"]
-        pub flt0awhtr: FLT0AWHTR,
-        #[doc = "0x124 - analog watchdog low threshold register"]
-        pub flt0awltr: FLT0AWLTR,
-        #[doc = "0x128 - analog watchdog status register"]
-        pub flt0awsr: FLT0AWSR,
-        #[doc = "0x12c - analog watchdog clear flag register"]
-        pub flt0awcfr: FLT0AWCFR,
-        #[doc = "0x130 - Extremes detector maximum register"]
-        pub flt0exmax: FLT0EXMAX,
-        #[doc = "0x134 - Extremes detector minimum register"]
-        pub flt0exmin: FLT0EXMIN,
-        #[doc = "0x138 - conversion timer register"]
-        pub flt0cnvtimr: FLT0CNVTIMR,
-        _reserved8: [u8; 68usize],
-        #[doc = "0x180 - control register 1"]
-        pub flt1cr1: FLT1CR1,
-        #[doc = "0x184 - control register 2"]
-        pub flt1cr2: FLT1CR2,
-        #[doc = "0x188 - interrupt and status register"]
-        pub flt1isr: FLT1ISR,
-        #[doc = "0x18c - interrupt flag clear register"]
-        pub flt1icr: FLT1ICR,
-        #[doc = "0x190 - injected channel group selection register"]
-        pub flt1jchgr: FLT1JCHGR,
-        #[doc = "0x194 - filter control register"]
-        pub flt1fcr: FLT1FCR,
-        #[doc = "0x198 - data register for injected group"]
-        pub flt1jdatar: FLT1JDATAR,
-        #[doc = "0x19c - data register for the regular channel"]
-        pub flt1rdatar: FLT1RDATAR,
-        #[doc = "0x1a0 - analog watchdog high threshold register"]
-        pub flt1awhtr: FLT1AWHTR,
-        #[doc = "0x1a4 - analog watchdog low threshold register"]
-        pub flt1awltr: FLT1AWLTR,
-        #[doc = "0x1a8 - analog watchdog status register"]
-        pub flt1awsr: FLT1AWSR,
-        #[doc = "0x1ac - analog watchdog clear flag register"]
-        pub flt1awcfr: FLT1AWCFR,
-        #[doc = "0x1b0 - Extremes detector maximum register"]
-        pub flt1exmax: FLT1EXMAX,
-        #[doc = "0x1b4 - Extremes detector minimum register"]
-        pub flt1exmin: FLT1EXMIN,
-        #[doc = "0x1b8 - conversion timer register"]
-        pub flt1cnvtimr: FLT1CNVTIMR,
-        _reserved9: [u8; 68usize],
-        #[doc = "0x200 - control register 1"]
-        pub flt2cr1: FLT2CR1,
-        #[doc = "0x204 - control register 2"]
-        pub flt2cr2: FLT2CR2,
-        #[doc = "0x208 - interrupt and status register"]
-        pub flt2isr: FLT2ISR,
-        #[doc = "0x20c - interrupt flag clear register"]
-        pub flt2icr: FLT2ICR,
-        #[doc = "0x210 - injected channel group selection register"]
-        pub flt2jchgr: FLT2JCHGR,
-        #[doc = "0x214 - filter control register"]
-        pub flt2fcr: FLT2FCR,
-        #[doc = "0x218 - data register for injected group"]
-        pub flt2jdatar: FLT2JDATAR,
-        #[doc = "0x21c - data register for the regular channel"]
-        pub flt2rdatar: FLT2RDATAR,
-        #[doc = "0x220 - analog watchdog high threshold register"]
-        pub flt2awhtr: FLT2AWHTR,
-        #[doc = "0x224 - analog watchdog low threshold register"]
-        pub flt2awltr: FLT2AWLTR,
-        #[doc = "0x228 - analog watchdog status register"]
-        pub flt2awsr: FLT2AWSR,
-        #[doc = "0x22c - analog watchdog clear flag register"]
-        pub flt2awcfr: FLT2AWCFR,
-        #[doc = "0x230 - Extremes detector maximum register"]
-        pub flt2exmax: FLT2EXMAX,
-        #[doc = "0x234 - Extremes detector minimum register"]
-        pub flt2exmin: FLT2EXMIN,
-        #[doc = "0x238 - conversion timer register"]
-        pub flt2cnvtimr: FLT2CNVTIMR,
-        _reserved10: [u8; 68usize],
-        #[doc = "0x280 - control register 1"]
-        pub flt3cr1: FLT3CR1,
-        #[doc = "0x284 - control register 2"]
-        pub flt3cr2: FLT3CR2,
-        #[doc = "0x288 - interrupt and status register"]
-        pub flt3isr: FLT3ISR,
-        #[doc = "0x28c - interrupt flag clear register"]
-        pub flt3icr: FLT3ICR,
-        #[doc = "0x290 - injected channel group selection register"]
-        pub flt3jchgr: FLT3JCHGR,
-        #[doc = "0x294 - filter control register"]
-        pub flt3fcr: FLT3FCR,
-        #[doc = "0x298 - data register for injected group"]
-        pub flt3jdatar: FLT3JDATAR,
-        #[doc = "0x29c - data register for the regular channel"]
-        pub flt3rdatar: FLT3RDATAR,
-        #[doc = "0x2a0 - analog watchdog high threshold register"]
-        pub flt3awhtr: FLT3AWHTR,
-        #[doc = "0x2a4 - analog watchdog low threshold register"]
-        pub flt3awltr: FLT3AWLTR,
-        #[doc = "0x2a8 - analog watchdog status register"]
-        pub flt3awsr: FLT3AWSR,
-        #[doc = "0x2ac - analog watchdog clear flag register"]
-        pub flt3awcfr: FLT3AWCFR,
-        #[doc = "0x2b0 - Extremes detector maximum register"]
-        pub flt3exmax: FLT3EXMAX,
-        #[doc = "0x2b4 - Extremes detector minimum register"]
-        pub flt3exmin: FLT3EXMIN,
-        #[doc = "0x2b8 - conversion timer register"]
-        pub flt3cnvtimr: FLT3CNVTIMR,
-    }
-    #[doc = "channel configuration y register"]
-    pub struct CH0CFGR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel configuration y register"]
-    pub mod ch0cfgr1 {
-        #[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::CH0CFGR1 {
-            #[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 = r" Value of the field"]
-        pub struct DFSDMENR {
-            bits: bool,
-        }
-        impl DFSDMENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKOUTSRCR {
-            bits: bool,
-        }
-        impl CKOUTSRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKOUTDIVR {
-            bits: u8,
-        }
-        impl CKOUTDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATPACKR {
-            bits: u8,
-        }
-        impl DATPACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATMPXR {
-            bits: u8,
-        }
-        impl DATMPXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHINSELR {
-            bits: bool,
-        }
-        impl CHINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENR {
-            bits: bool,
-        }
-        impl CHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKABENR {
-            bits: bool,
-        }
-        impl CKABENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDENR {
-            bits: bool,
-        }
-        impl SCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPICKSELR {
-            bits: u8,
-        }
-        impl SPICKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SITPR {
-            bits: u8,
-        }
-        impl SITPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DFSDMENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFSDMENW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKOUTSRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKOUTSRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKOUTDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKOUTDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATPACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATPACKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATMPXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATMPXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKABENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPICKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPICKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SITPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SITPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 = "Bit 31 - DFSDMEN"]
-            #[inline]
-            pub fn dfsdmen(&self) -> DFSDMENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFSDMENR { bits }
-            }
-            #[doc = "Bit 30 - CKOUTSRC"]
-            #[inline]
-            pub fn ckoutsrc(&self) -> CKOUTSRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKOUTSRCR { bits }
-            }
-            #[doc = "Bits 16:23 - CKOUTDIV"]
-            #[inline]
-            pub fn ckoutdiv(&self) -> CKOUTDIVR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKOUTDIVR { bits }
-            }
-            #[doc = "Bits 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&self) -> DATPACKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATPACKR { bits }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&self) -> DATMPXR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATMPXR { bits }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&self) -> CHINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHINSELR { bits }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&self) -> CHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENR { bits }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&self) -> CKABENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABENR { bits }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&self) -> SCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDENR { bits }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&self) -> SPICKSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SPICKSELR { bits }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&self) -> SITPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SITPR { bits }
-            }
-        }
-        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 31 - DFSDMEN"]
-            #[inline]
-            pub fn dfsdmen(&mut self) -> _DFSDMENW {
-                _DFSDMENW { w: self }
-            }
-            #[doc = "Bit 30 - CKOUTSRC"]
-            #[inline]
-            pub fn ckoutsrc(&mut self) -> _CKOUTSRCW {
-                _CKOUTSRCW { w: self }
-            }
-            #[doc = "Bits 16:23 - CKOUTDIV"]
-            #[inline]
-            pub fn ckoutdiv(&mut self) -> _CKOUTDIVW {
-                _CKOUTDIVW { w: self }
-            }
-            #[doc = "Bits 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&mut self) -> _DATPACKW {
-                _DATPACKW { w: self }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&mut self) -> _DATMPXW {
-                _DATMPXW { w: self }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&mut self) -> _CHINSELW {
-                _CHINSELW { w: self }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&mut self) -> _CHENW {
-                _CHENW { w: self }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&mut self) -> _CKABENW {
-                _CKABENW { w: self }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&mut self) -> _SCDENW {
-                _SCDENW { w: self }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&mut self) -> _SPICKSELW {
-                _SPICKSELW { w: self }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&mut self) -> _SITPW {
-                _SITPW { w: self }
-            }
-        }
-    }
-    #[doc = "channel configuration y register"]
-    pub struct CH0CFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel configuration y register"]
-    pub mod ch0cfgr2 {
-        #[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::CH0CFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct OFFSETR {
-            bits: u32,
-        }
-        impl OFFSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTRBSR {
-            bits: u8,
-        }
-        impl DTRBSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OFFSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OFFSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTRBSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTRBSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&self) -> OFFSETR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                OFFSETR { bits }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&self) -> DTRBSR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTRBSR { bits }
-            }
-        }
-        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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&mut self) -> _OFFSETW {
-                _OFFSETW { w: self }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&mut self) -> _DTRBSW {
-                _DTRBSW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog and short-circuit detector register"]
-    pub struct CH0AWSCDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog and short-circuit detector register"]
-    pub mod ch0awscdr {
-        #[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::CH0AWSCDR {
-            #[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 = r" Value of the field"]
-        pub struct AWFORDR {
-            bits: u8,
-        }
-        impl AWFORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWFOSRR {
-            bits: u8,
-        }
-        impl AWFOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKSCDR {
-            bits: u8,
-        }
-        impl BKSCDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDTR {
-            bits: u8,
-        }
-        impl SCDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKSCDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKSCDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&self) -> AWFORDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFORDR { bits }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&self) -> AWFOSRR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFOSRR { bits }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&self) -> BKSCDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKSCDR { bits }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&self) -> SCDTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDTR { bits }
-            }
-        }
-        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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&mut self) -> _AWFORDW {
-                _AWFORDW { w: self }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&mut self) -> _AWFOSRW {
-                _AWFOSRW { w: self }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&mut self) -> _BKSCDW {
-                _BKSCDW { w: self }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&mut self) -> _SCDTW {
-                _SCDTW { w: self }
-            }
-        }
-    }
-    #[doc = "channel watchdog filter data register"]
-    pub struct CH0WDATR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel watchdog filter data register"]
-    pub mod ch0wdatr {
-        #[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::CH0WDATR {
-            #[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 = r" Value of the field"]
-        pub struct WDATAR {
-            bits: u16,
-        }
-        impl WDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&self) -> WDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WDATAR { bits }
-            }
-        }
-        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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&mut self) -> _WDATAW {
-                _WDATAW { w: self }
-            }
-        }
-    }
-    #[doc = "channel data input register"]
-    pub struct CH0DATINR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel data input register"]
-    pub mod ch0datinr {
-        #[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::CH0DATINR {
-            #[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 = r" Value of the field"]
-        pub struct INDAT1R {
-            bits: u16,
-        }
-        impl INDAT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INDAT0R {
-            bits: u16,
-        }
-        impl INDAT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&self) -> INDAT1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT1R { bits }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&self) -> INDAT0R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT0R { bits }
-            }
-        }
-        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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&mut self) -> _INDAT1W {
-                _INDAT1W { w: self }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&mut self) -> _INDAT0W {
-                _INDAT0W { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG1R1"]
-    pub struct CH1CFGR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG1R1"]
-    pub mod ch1cfgr1 {
-        #[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::CH1CFGR1 {
-            #[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 = r" Value of the field"]
-        pub struct DATPACKR {
-            bits: u8,
-        }
-        impl DATPACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATMPXR {
-            bits: u8,
-        }
-        impl DATMPXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHINSELR {
-            bits: bool,
-        }
-        impl CHINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENR {
-            bits: bool,
-        }
-        impl CHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKABENR {
-            bits: bool,
-        }
-        impl CKABENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDENR {
-            bits: bool,
-        }
-        impl SCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPICKSELR {
-            bits: u8,
-        }
-        impl SPICKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SITPR {
-            bits: u8,
-        }
-        impl SITPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATPACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATPACKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATMPXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATMPXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKABENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPICKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPICKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SITPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SITPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&self) -> DATPACKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATPACKR { bits }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&self) -> DATMPXR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATMPXR { bits }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&self) -> CHINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHINSELR { bits }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&self) -> CHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENR { bits }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&self) -> CKABENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABENR { bits }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&self) -> SCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDENR { bits }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&self) -> SPICKSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SPICKSELR { bits }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&self) -> SITPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SITPR { bits }
-            }
-        }
-        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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&mut self) -> _DATPACKW {
-                _DATPACKW { w: self }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&mut self) -> _DATMPXW {
-                _DATMPXW { w: self }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&mut self) -> _CHINSELW {
-                _CHINSELW { w: self }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&mut self) -> _CHENW {
-                _CHENW { w: self }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&mut self) -> _CKABENW {
-                _CKABENW { w: self }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&mut self) -> _SCDENW {
-                _SCDENW { w: self }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&mut self) -> _SPICKSELW {
-                _SPICKSELW { w: self }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&mut self) -> _SITPW {
-                _SITPW { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG1R2"]
-    pub struct CH1CFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG1R2"]
-    pub mod ch1cfgr2 {
-        #[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::CH1CFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct OFFSETR {
-            bits: u32,
-        }
-        impl OFFSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTRBSR {
-            bits: u8,
-        }
-        impl DTRBSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OFFSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OFFSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTRBSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTRBSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&self) -> OFFSETR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                OFFSETR { bits }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&self) -> DTRBSR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTRBSR { bits }
-            }
-        }
-        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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&mut self) -> _OFFSETW {
-                _OFFSETW { w: self }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&mut self) -> _DTRBSW {
-                _DTRBSW { w: self }
-            }
-        }
-    }
-    #[doc = "AWSCD1R"]
-    pub struct CH1AWSCDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AWSCD1R"]
-    pub mod ch1awscdr {
-        #[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::CH1AWSCDR {
-            #[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 = r" Value of the field"]
-        pub struct AWFORDR {
-            bits: u8,
-        }
-        impl AWFORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWFOSRR {
-            bits: u8,
-        }
-        impl AWFOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKSCDR {
-            bits: u8,
-        }
-        impl BKSCDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDTR {
-            bits: u8,
-        }
-        impl SCDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKSCDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKSCDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&self) -> AWFORDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFORDR { bits }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&self) -> AWFOSRR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFOSRR { bits }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&self) -> BKSCDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKSCDR { bits }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&self) -> SCDTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDTR { bits }
-            }
-        }
-        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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&mut self) -> _AWFORDW {
-                _AWFORDW { w: self }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&mut self) -> _AWFOSRW {
-                _AWFOSRW { w: self }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&mut self) -> _BKSCDW {
-                _BKSCDW { w: self }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&mut self) -> _SCDTW {
-                _SCDTW { w: self }
-            }
-        }
-    }
-    #[doc = "CHWDAT1R"]
-    pub struct CH1WDATR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHWDAT1R"]
-    pub mod ch1wdatr {
-        #[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::CH1WDATR {
-            #[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 = r" Value of the field"]
-        pub struct WDATAR {
-            bits: u16,
-        }
-        impl WDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&self) -> WDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WDATAR { bits }
-            }
-        }
-        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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&mut self) -> _WDATAW {
-                _WDATAW { w: self }
-            }
-        }
-    }
-    #[doc = "CHDATIN1R"]
-    pub struct CH1DATINR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHDATIN1R"]
-    pub mod ch1datinr {
-        #[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::CH1DATINR {
-            #[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 = r" Value of the field"]
-        pub struct INDAT1R {
-            bits: u16,
-        }
-        impl INDAT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INDAT0R {
-            bits: u16,
-        }
-        impl INDAT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&self) -> INDAT1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT1R { bits }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&self) -> INDAT0R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT0R { bits }
-            }
-        }
-        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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&mut self) -> _INDAT1W {
-                _INDAT1W { w: self }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&mut self) -> _INDAT0W {
-                _INDAT0W { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG2R1"]
-    pub struct CH2CFGR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG2R1"]
-    pub mod ch2cfgr1 {
-        #[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::CH2CFGR1 {
-            #[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 = r" Value of the field"]
-        pub struct DATPACKR {
-            bits: u8,
-        }
-        impl DATPACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATMPXR {
-            bits: u8,
-        }
-        impl DATMPXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHINSELR {
-            bits: bool,
-        }
-        impl CHINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENR {
-            bits: bool,
-        }
-        impl CHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKABENR {
-            bits: bool,
-        }
-        impl CKABENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDENR {
-            bits: bool,
-        }
-        impl SCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPICKSELR {
-            bits: u8,
-        }
-        impl SPICKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SITPR {
-            bits: u8,
-        }
-        impl SITPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATPACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATPACKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATMPXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATMPXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKABENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPICKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPICKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SITPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SITPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&self) -> DATPACKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATPACKR { bits }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&self) -> DATMPXR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATMPXR { bits }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&self) -> CHINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHINSELR { bits }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&self) -> CHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENR { bits }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&self) -> CKABENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABENR { bits }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&self) -> SCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDENR { bits }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&self) -> SPICKSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SPICKSELR { bits }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&self) -> SITPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SITPR { bits }
-            }
-        }
-        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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&mut self) -> _DATPACKW {
-                _DATPACKW { w: self }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&mut self) -> _DATMPXW {
-                _DATMPXW { w: self }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&mut self) -> _CHINSELW {
-                _CHINSELW { w: self }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&mut self) -> _CHENW {
-                _CHENW { w: self }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&mut self) -> _CKABENW {
-                _CKABENW { w: self }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&mut self) -> _SCDENW {
-                _SCDENW { w: self }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&mut self) -> _SPICKSELW {
-                _SPICKSELW { w: self }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&mut self) -> _SITPW {
-                _SITPW { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG2R2"]
-    pub struct CH2CFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG2R2"]
-    pub mod ch2cfgr2 {
-        #[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::CH2CFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct OFFSETR {
-            bits: u32,
-        }
-        impl OFFSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTRBSR {
-            bits: u8,
-        }
-        impl DTRBSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OFFSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OFFSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTRBSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTRBSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&self) -> OFFSETR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                OFFSETR { bits }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&self) -> DTRBSR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTRBSR { bits }
-            }
-        }
-        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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&mut self) -> _OFFSETW {
-                _OFFSETW { w: self }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&mut self) -> _DTRBSW {
-                _DTRBSW { w: self }
-            }
-        }
-    }
-    #[doc = "AWSCD2R"]
-    pub struct CH2AWSCDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AWSCD2R"]
-    pub mod ch2awscdr {
-        #[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::CH2AWSCDR {
-            #[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 = r" Value of the field"]
-        pub struct AWFORDR {
-            bits: u8,
-        }
-        impl AWFORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWFOSRR {
-            bits: u8,
-        }
-        impl AWFOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKSCDR {
-            bits: u8,
-        }
-        impl BKSCDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDTR {
-            bits: u8,
-        }
-        impl SCDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKSCDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKSCDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&self) -> AWFORDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFORDR { bits }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&self) -> AWFOSRR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFOSRR { bits }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&self) -> BKSCDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKSCDR { bits }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&self) -> SCDTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDTR { bits }
-            }
-        }
-        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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&mut self) -> _AWFORDW {
-                _AWFORDW { w: self }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&mut self) -> _AWFOSRW {
-                _AWFOSRW { w: self }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&mut self) -> _BKSCDW {
-                _BKSCDW { w: self }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&mut self) -> _SCDTW {
-                _SCDTW { w: self }
-            }
-        }
-    }
-    #[doc = "CHWDAT2R"]
-    pub struct CH2WDATR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHWDAT2R"]
-    pub mod ch2wdatr {
-        #[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::CH2WDATR {
-            #[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 = r" Value of the field"]
-        pub struct WDATAR {
-            bits: u16,
-        }
-        impl WDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&self) -> WDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WDATAR { bits }
-            }
-        }
-        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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&mut self) -> _WDATAW {
-                _WDATAW { w: self }
-            }
-        }
-    }
-    #[doc = "CHDATIN2R"]
-    pub struct CH2DATINR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHDATIN2R"]
-    pub mod ch2datinr {
-        #[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::CH2DATINR {
-            #[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 = r" Value of the field"]
-        pub struct INDAT1R {
-            bits: u16,
-        }
-        impl INDAT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INDAT0R {
-            bits: u16,
-        }
-        impl INDAT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&self) -> INDAT1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT1R { bits }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&self) -> INDAT0R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT0R { bits }
-            }
-        }
-        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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&mut self) -> _INDAT1W {
-                _INDAT1W { w: self }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&mut self) -> _INDAT0W {
-                _INDAT0W { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG3R1"]
-    pub struct CH3CFGR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG3R1"]
-    pub mod ch3cfgr1 {
-        #[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::CH3CFGR1 {
-            #[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 = r" Value of the field"]
-        pub struct DATPACKR {
-            bits: u8,
-        }
-        impl DATPACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATMPXR {
-            bits: u8,
-        }
-        impl DATMPXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHINSELR {
-            bits: bool,
-        }
-        impl CHINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENR {
-            bits: bool,
-        }
-        impl CHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKABENR {
-            bits: bool,
-        }
-        impl CKABENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDENR {
-            bits: bool,
-        }
-        impl SCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPICKSELR {
-            bits: u8,
-        }
-        impl SPICKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SITPR {
-            bits: u8,
-        }
-        impl SITPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATPACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATPACKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATMPXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATMPXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKABENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPICKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPICKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SITPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SITPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&self) -> DATPACKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATPACKR { bits }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&self) -> DATMPXR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATMPXR { bits }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&self) -> CHINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHINSELR { bits }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&self) -> CHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENR { bits }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&self) -> CKABENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABENR { bits }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&self) -> SCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDENR { bits }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&self) -> SPICKSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SPICKSELR { bits }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&self) -> SITPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SITPR { bits }
-            }
-        }
-        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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&mut self) -> _DATPACKW {
-                _DATPACKW { w: self }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&mut self) -> _DATMPXW {
-                _DATMPXW { w: self }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&mut self) -> _CHINSELW {
-                _CHINSELW { w: self }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&mut self) -> _CHENW {
-                _CHENW { w: self }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&mut self) -> _CKABENW {
-                _CKABENW { w: self }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&mut self) -> _SCDENW {
-                _SCDENW { w: self }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&mut self) -> _SPICKSELW {
-                _SPICKSELW { w: self }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&mut self) -> _SITPW {
-                _SITPW { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG3R2"]
-    pub struct CH3CFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG3R2"]
-    pub mod ch3cfgr2 {
-        #[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::CH3CFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct OFFSETR {
-            bits: u32,
-        }
-        impl OFFSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTRBSR {
-            bits: u8,
-        }
-        impl DTRBSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OFFSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OFFSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTRBSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTRBSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&self) -> OFFSETR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                OFFSETR { bits }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&self) -> DTRBSR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTRBSR { bits }
-            }
-        }
-        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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&mut self) -> _OFFSETW {
-                _OFFSETW { w: self }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&mut self) -> _DTRBSW {
-                _DTRBSW { w: self }
-            }
-        }
-    }
-    #[doc = "AWSCD3R"]
-    pub struct CH3AWSCDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AWSCD3R"]
-    pub mod ch3awscdr {
-        #[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::CH3AWSCDR {
-            #[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 = r" Value of the field"]
-        pub struct AWFORDR {
-            bits: u8,
-        }
-        impl AWFORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWFOSRR {
-            bits: u8,
-        }
-        impl AWFOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKSCDR {
-            bits: u8,
-        }
-        impl BKSCDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDTR {
-            bits: u8,
-        }
-        impl SCDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKSCDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKSCDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&self) -> AWFORDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFORDR { bits }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&self) -> AWFOSRR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFOSRR { bits }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&self) -> BKSCDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKSCDR { bits }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&self) -> SCDTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDTR { bits }
-            }
-        }
-        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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&mut self) -> _AWFORDW {
-                _AWFORDW { w: self }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&mut self) -> _AWFOSRW {
-                _AWFOSRW { w: self }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&mut self) -> _BKSCDW {
-                _BKSCDW { w: self }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&mut self) -> _SCDTW {
-                _SCDTW { w: self }
-            }
-        }
-    }
-    #[doc = "CHWDAT3R"]
-    pub struct CH3WDATR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHWDAT3R"]
-    pub mod ch3wdatr {
-        #[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::CH3WDATR {
-            #[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 = r" Value of the field"]
-        pub struct WDATAR {
-            bits: u16,
-        }
-        impl WDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&self) -> WDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WDATAR { bits }
-            }
-        }
-        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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&mut self) -> _WDATAW {
-                _WDATAW { w: self }
-            }
-        }
-    }
-    #[doc = "CHDATIN3R"]
-    pub struct CH3DATINR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHDATIN3R"]
-    pub mod ch3datinr {
-        #[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::CH3DATINR {
-            #[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 = r" Value of the field"]
-        pub struct INDAT1R {
-            bits: u16,
-        }
-        impl INDAT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INDAT0R {
-            bits: u16,
-        }
-        impl INDAT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&self) -> INDAT1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT1R { bits }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&self) -> INDAT0R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT0R { bits }
-            }
-        }
-        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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&mut self) -> _INDAT1W {
-                _INDAT1W { w: self }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&mut self) -> _INDAT0W {
-                _INDAT0W { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG4R1"]
-    pub struct CH4CFGR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG4R1"]
-    pub mod ch4cfgr1 {
-        #[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::CH4CFGR1 {
-            #[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 = r" Value of the field"]
-        pub struct DATPACKR {
-            bits: u8,
-        }
-        impl DATPACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATMPXR {
-            bits: u8,
-        }
-        impl DATMPXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHINSELR {
-            bits: bool,
-        }
-        impl CHINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENR {
-            bits: bool,
-        }
-        impl CHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKABENR {
-            bits: bool,
-        }
-        impl CKABENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDENR {
-            bits: bool,
-        }
-        impl SCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPICKSELR {
-            bits: u8,
-        }
-        impl SPICKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SITPR {
-            bits: u8,
-        }
-        impl SITPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATPACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATPACKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATMPXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATMPXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKABENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPICKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPICKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SITPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SITPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&self) -> DATPACKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATPACKR { bits }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&self) -> DATMPXR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATMPXR { bits }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&self) -> CHINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHINSELR { bits }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&self) -> CHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENR { bits }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&self) -> CKABENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABENR { bits }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&self) -> SCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDENR { bits }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&self) -> SPICKSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SPICKSELR { bits }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&self) -> SITPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SITPR { bits }
-            }
-        }
-        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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&mut self) -> _DATPACKW {
-                _DATPACKW { w: self }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&mut self) -> _DATMPXW {
-                _DATMPXW { w: self }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&mut self) -> _CHINSELW {
-                _CHINSELW { w: self }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&mut self) -> _CHENW {
-                _CHENW { w: self }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&mut self) -> _CKABENW {
-                _CKABENW { w: self }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&mut self) -> _SCDENW {
-                _SCDENW { w: self }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&mut self) -> _SPICKSELW {
-                _SPICKSELW { w: self }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&mut self) -> _SITPW {
-                _SITPW { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG4R2"]
-    pub struct CH4CFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG4R2"]
-    pub mod ch4cfgr2 {
-        #[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::CH4CFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct OFFSETR {
-            bits: u32,
-        }
-        impl OFFSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTRBSR {
-            bits: u8,
-        }
-        impl DTRBSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OFFSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OFFSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTRBSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTRBSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&self) -> OFFSETR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                OFFSETR { bits }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&self) -> DTRBSR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTRBSR { bits }
-            }
-        }
-        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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&mut self) -> _OFFSETW {
-                _OFFSETW { w: self }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&mut self) -> _DTRBSW {
-                _DTRBSW { w: self }
-            }
-        }
-    }
-    #[doc = "AWSCD4R"]
-    pub struct CH4AWSCDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AWSCD4R"]
-    pub mod ch4awscdr {
-        #[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::CH4AWSCDR {
-            #[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 = r" Value of the field"]
-        pub struct AWFORDR {
-            bits: u8,
-        }
-        impl AWFORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWFOSRR {
-            bits: u8,
-        }
-        impl AWFOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKSCDR {
-            bits: u8,
-        }
-        impl BKSCDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDTR {
-            bits: u8,
-        }
-        impl SCDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKSCDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKSCDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&self) -> AWFORDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFORDR { bits }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&self) -> AWFOSRR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFOSRR { bits }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&self) -> BKSCDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKSCDR { bits }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&self) -> SCDTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDTR { bits }
-            }
-        }
-        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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&mut self) -> _AWFORDW {
-                _AWFORDW { w: self }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&mut self) -> _AWFOSRW {
-                _AWFOSRW { w: self }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&mut self) -> _BKSCDW {
-                _BKSCDW { w: self }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&mut self) -> _SCDTW {
-                _SCDTW { w: self }
-            }
-        }
-    }
-    #[doc = "CHWDAT4R"]
-    pub struct CH4WDATR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHWDAT4R"]
-    pub mod ch4wdatr {
-        #[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::CH4WDATR {
-            #[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 = r" Value of the field"]
-        pub struct WDATAR {
-            bits: u16,
-        }
-        impl WDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&self) -> WDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WDATAR { bits }
-            }
-        }
-        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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&mut self) -> _WDATAW {
-                _WDATAW { w: self }
-            }
-        }
-    }
-    #[doc = "CHDATIN4R"]
-    pub struct CH4DATINR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHDATIN4R"]
-    pub mod ch4datinr {
-        #[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::CH4DATINR {
-            #[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 = r" Value of the field"]
-        pub struct INDAT1R {
-            bits: u16,
-        }
-        impl INDAT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INDAT0R {
-            bits: u16,
-        }
-        impl INDAT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&self) -> INDAT1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT1R { bits }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&self) -> INDAT0R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT0R { bits }
-            }
-        }
-        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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&mut self) -> _INDAT1W {
-                _INDAT1W { w: self }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&mut self) -> _INDAT0W {
-                _INDAT0W { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG5R1"]
-    pub struct CH5CFGR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG5R1"]
-    pub mod ch5cfgr1 {
-        #[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::CH5CFGR1 {
-            #[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 = r" Value of the field"]
-        pub struct DATPACKR {
-            bits: u8,
-        }
-        impl DATPACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATMPXR {
-            bits: u8,
-        }
-        impl DATMPXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHINSELR {
-            bits: bool,
-        }
-        impl CHINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENR {
-            bits: bool,
-        }
-        impl CHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKABENR {
-            bits: bool,
-        }
-        impl CKABENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDENR {
-            bits: bool,
-        }
-        impl SCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPICKSELR {
-            bits: u8,
-        }
-        impl SPICKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SITPR {
-            bits: u8,
-        }
-        impl SITPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATPACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATPACKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATMPXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATMPXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKABENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPICKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPICKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SITPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SITPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&self) -> DATPACKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATPACKR { bits }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&self) -> DATMPXR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATMPXR { bits }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&self) -> CHINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHINSELR { bits }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&self) -> CHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENR { bits }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&self) -> CKABENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABENR { bits }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&self) -> SCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDENR { bits }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&self) -> SPICKSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SPICKSELR { bits }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&self) -> SITPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SITPR { bits }
-            }
-        }
-        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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&mut self) -> _DATPACKW {
-                _DATPACKW { w: self }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&mut self) -> _DATMPXW {
-                _DATMPXW { w: self }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&mut self) -> _CHINSELW {
-                _CHINSELW { w: self }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&mut self) -> _CHENW {
-                _CHENW { w: self }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&mut self) -> _CKABENW {
-                _CKABENW { w: self }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&mut self) -> _SCDENW {
-                _SCDENW { w: self }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&mut self) -> _SPICKSELW {
-                _SPICKSELW { w: self }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&mut self) -> _SITPW {
-                _SITPW { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG5R2"]
-    pub struct CH5CFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG5R2"]
-    pub mod ch5cfgr2 {
-        #[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::CH5CFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct OFFSETR {
-            bits: u32,
-        }
-        impl OFFSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTRBSR {
-            bits: u8,
-        }
-        impl DTRBSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OFFSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OFFSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTRBSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTRBSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&self) -> OFFSETR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                OFFSETR { bits }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&self) -> DTRBSR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTRBSR { bits }
-            }
-        }
-        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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&mut self) -> _OFFSETW {
-                _OFFSETW { w: self }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&mut self) -> _DTRBSW {
-                _DTRBSW { w: self }
-            }
-        }
-    }
-    #[doc = "AWSCD5R"]
-    pub struct CH5AWSCDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AWSCD5R"]
-    pub mod ch5awscdr {
-        #[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::CH5AWSCDR {
-            #[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 = r" Value of the field"]
-        pub struct AWFORDR {
-            bits: u8,
-        }
-        impl AWFORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWFOSRR {
-            bits: u8,
-        }
-        impl AWFOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKSCDR {
-            bits: u8,
-        }
-        impl BKSCDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDTR {
-            bits: u8,
-        }
-        impl SCDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKSCDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKSCDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&self) -> AWFORDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFORDR { bits }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&self) -> AWFOSRR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFOSRR { bits }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&self) -> BKSCDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKSCDR { bits }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&self) -> SCDTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDTR { bits }
-            }
-        }
-        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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&mut self) -> _AWFORDW {
-                _AWFORDW { w: self }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&mut self) -> _AWFOSRW {
-                _AWFOSRW { w: self }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&mut self) -> _BKSCDW {
-                _BKSCDW { w: self }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&mut self) -> _SCDTW {
-                _SCDTW { w: self }
-            }
-        }
-    }
-    #[doc = "CHWDAT5R"]
-    pub struct CH5WDATR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHWDAT5R"]
-    pub mod ch5wdatr {
-        #[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::CH5WDATR {
-            #[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 = r" Value of the field"]
-        pub struct WDATAR {
-            bits: u16,
-        }
-        impl WDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&self) -> WDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WDATAR { bits }
-            }
-        }
-        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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&mut self) -> _WDATAW {
-                _WDATAW { w: self }
-            }
-        }
-    }
-    #[doc = "CHDATIN5R"]
-    pub struct CH5DATINR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHDATIN5R"]
-    pub mod ch5datinr {
-        #[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::CH5DATINR {
-            #[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 = r" Value of the field"]
-        pub struct INDAT1R {
-            bits: u16,
-        }
-        impl INDAT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INDAT0R {
-            bits: u16,
-        }
-        impl INDAT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&self) -> INDAT1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT1R { bits }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&self) -> INDAT0R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT0R { bits }
-            }
-        }
-        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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&mut self) -> _INDAT1W {
-                _INDAT1W { w: self }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&mut self) -> _INDAT0W {
-                _INDAT0W { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG6R1"]
-    pub struct CH6CFGR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG6R1"]
-    pub mod ch6cfgr1 {
-        #[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::CH6CFGR1 {
-            #[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 = r" Value of the field"]
-        pub struct DATPACKR {
-            bits: u8,
-        }
-        impl DATPACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATMPXR {
-            bits: u8,
-        }
-        impl DATMPXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHINSELR {
-            bits: bool,
-        }
-        impl CHINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENR {
-            bits: bool,
-        }
-        impl CHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKABENR {
-            bits: bool,
-        }
-        impl CKABENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDENR {
-            bits: bool,
-        }
-        impl SCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPICKSELR {
-            bits: u8,
-        }
-        impl SPICKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SITPR {
-            bits: u8,
-        }
-        impl SITPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATPACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATPACKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATMPXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATMPXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKABENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPICKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPICKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SITPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SITPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&self) -> DATPACKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATPACKR { bits }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&self) -> DATMPXR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATMPXR { bits }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&self) -> CHINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHINSELR { bits }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&self) -> CHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENR { bits }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&self) -> CKABENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABENR { bits }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&self) -> SCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDENR { bits }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&self) -> SPICKSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SPICKSELR { bits }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&self) -> SITPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SITPR { bits }
-            }
-        }
-        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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&mut self) -> _DATPACKW {
-                _DATPACKW { w: self }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&mut self) -> _DATMPXW {
-                _DATMPXW { w: self }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&mut self) -> _CHINSELW {
-                _CHINSELW { w: self }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&mut self) -> _CHENW {
-                _CHENW { w: self }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&mut self) -> _CKABENW {
-                _CKABENW { w: self }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&mut self) -> _SCDENW {
-                _SCDENW { w: self }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&mut self) -> _SPICKSELW {
-                _SPICKSELW { w: self }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&mut self) -> _SITPW {
-                _SITPW { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG6R2"]
-    pub struct CH6CFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG6R2"]
-    pub mod ch6cfgr2 {
-        #[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::CH6CFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct OFFSETR {
-            bits: u32,
-        }
-        impl OFFSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTRBSR {
-            bits: u8,
-        }
-        impl DTRBSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OFFSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OFFSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTRBSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTRBSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&self) -> OFFSETR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                OFFSETR { bits }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&self) -> DTRBSR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTRBSR { bits }
-            }
-        }
-        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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&mut self) -> _OFFSETW {
-                _OFFSETW { w: self }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&mut self) -> _DTRBSW {
-                _DTRBSW { w: self }
-            }
-        }
-    }
-    #[doc = "AWSCD6R"]
-    pub struct CH6AWSCDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AWSCD6R"]
-    pub mod ch6awscdr {
-        #[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::CH6AWSCDR {
-            #[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 = r" Value of the field"]
-        pub struct AWFORDR {
-            bits: u8,
-        }
-        impl AWFORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWFOSRR {
-            bits: u8,
-        }
-        impl AWFOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKSCDR {
-            bits: u8,
-        }
-        impl BKSCDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDTR {
-            bits: u8,
-        }
-        impl SCDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKSCDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKSCDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&self) -> AWFORDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFORDR { bits }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&self) -> AWFOSRR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFOSRR { bits }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&self) -> BKSCDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKSCDR { bits }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&self) -> SCDTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDTR { bits }
-            }
-        }
-        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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&mut self) -> _AWFORDW {
-                _AWFORDW { w: self }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&mut self) -> _AWFOSRW {
-                _AWFOSRW { w: self }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&mut self) -> _BKSCDW {
-                _BKSCDW { w: self }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&mut self) -> _SCDTW {
-                _SCDTW { w: self }
-            }
-        }
-    }
-    #[doc = "CHWDAT6R"]
-    pub struct CH6WDATR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHWDAT6R"]
-    pub mod ch6wdatr {
-        #[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::CH6WDATR {
-            #[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 = r" Value of the field"]
-        pub struct WDATAR {
-            bits: u16,
-        }
-        impl WDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&self) -> WDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WDATAR { bits }
-            }
-        }
-        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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&mut self) -> _WDATAW {
-                _WDATAW { w: self }
-            }
-        }
-    }
-    #[doc = "CHDATIN6R"]
-    pub struct CH6DATINR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHDATIN6R"]
-    pub mod ch6datinr {
-        #[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::CH6DATINR {
-            #[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 = r" Value of the field"]
-        pub struct INDAT1R {
-            bits: u16,
-        }
-        impl INDAT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INDAT0R {
-            bits: u16,
-        }
-        impl INDAT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&self) -> INDAT1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT1R { bits }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&self) -> INDAT0R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT0R { bits }
-            }
-        }
-        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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&mut self) -> _INDAT1W {
-                _INDAT1W { w: self }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&mut self) -> _INDAT0W {
-                _INDAT0W { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG7R1"]
-    pub struct CH7CFGR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG7R1"]
-    pub mod ch7cfgr1 {
-        #[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::CH7CFGR1 {
-            #[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 = r" Value of the field"]
-        pub struct DATPACKR {
-            bits: u8,
-        }
-        impl DATPACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATMPXR {
-            bits: u8,
-        }
-        impl DATMPXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CHINSELR {
-            bits: bool,
-        }
-        impl CHINSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENR {
-            bits: bool,
-        }
-        impl CHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CKABENR {
-            bits: bool,
-        }
-        impl CKABENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDENR {
-            bits: bool,
-        }
-        impl SCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SPICKSELR {
-            bits: u8,
-        }
-        impl SPICKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SITPR {
-            bits: u8,
-        }
-        impl SITPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATPACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATPACKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATMPXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATMPXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CHINSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHINSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CKABENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SPICKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SPICKSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SITPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SITPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&self) -> DATPACKR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATPACKR { bits }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&self) -> DATMPXR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATMPXR { bits }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&self) -> CHINSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHINSELR { bits }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&self) -> CHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENR { bits }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&self) -> CKABENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABENR { bits }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&self) -> SCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDENR { bits }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&self) -> SPICKSELR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SPICKSELR { bits }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&self) -> SITPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SITPR { bits }
-            }
-        }
-        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 14:15 - DATPACK"]
-            #[inline]
-            pub fn datpack(&mut self) -> _DATPACKW {
-                _DATPACKW { w: self }
-            }
-            #[doc = "Bits 12:13 - DATMPX"]
-            #[inline]
-            pub fn datmpx(&mut self) -> _DATMPXW {
-                _DATMPXW { w: self }
-            }
-            #[doc = "Bit 8 - CHINSEL"]
-            #[inline]
-            pub fn chinsel(&mut self) -> _CHINSELW {
-                _CHINSELW { w: self }
-            }
-            #[doc = "Bit 7 - CHEN"]
-            #[inline]
-            pub fn chen(&mut self) -> _CHENW {
-                _CHENW { w: self }
-            }
-            #[doc = "Bit 6 - CKABEN"]
-            #[inline]
-            pub fn ckaben(&mut self) -> _CKABENW {
-                _CKABENW { w: self }
-            }
-            #[doc = "Bit 5 - SCDEN"]
-            #[inline]
-            pub fn scden(&mut self) -> _SCDENW {
-                _SCDENW { w: self }
-            }
-            #[doc = "Bits 2:3 - SPICKSEL"]
-            #[inline]
-            pub fn spicksel(&mut self) -> _SPICKSELW {
-                _SPICKSELW { w: self }
-            }
-            #[doc = "Bits 0:1 - SITP"]
-            #[inline]
-            pub fn sitp(&mut self) -> _SITPW {
-                _SITPW { w: self }
-            }
-        }
-    }
-    #[doc = "CHCFG7R2"]
-    pub struct CH7CFGR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHCFG7R2"]
-    pub mod ch7cfgr2 {
-        #[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::CH7CFGR2 {
-            #[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 = r" Value of the field"]
-        pub struct OFFSETR {
-            bits: u32,
-        }
-        impl OFFSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DTRBSR {
-            bits: u8,
-        }
-        impl DTRBSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OFFSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OFFSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DTRBSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTRBSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 3;
-                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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&self) -> OFFSETR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                OFFSETR { bits }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&self) -> DTRBSR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DTRBSR { bits }
-            }
-        }
-        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 8:31 - OFFSET"]
-            #[inline]
-            pub fn offset(&mut self) -> _OFFSETW {
-                _OFFSETW { w: self }
-            }
-            #[doc = "Bits 3:7 - DTRBS"]
-            #[inline]
-            pub fn dtrbs(&mut self) -> _DTRBSW {
-                _DTRBSW { w: self }
-            }
-        }
-    }
-    #[doc = "AWSCD7R"]
-    pub struct CH7AWSCDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "AWSCD7R"]
-    pub mod ch7awscdr {
-        #[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::CH7AWSCDR {
-            #[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 = r" Value of the field"]
-        pub struct AWFORDR {
-            bits: u8,
-        }
-        impl AWFORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWFOSRR {
-            bits: u8,
-        }
-        impl AWFOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKSCDR {
-            bits: u8,
-        }
-        impl BKSCDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDTR {
-            bits: u8,
-        }
-        impl SCDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWFOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKSCDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKSCDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&self) -> AWFORDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFORDR { bits }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&self) -> AWFOSRR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWFOSRR { bits }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&self) -> BKSCDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKSCDR { bits }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&self) -> SCDTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDTR { bits }
-            }
-        }
-        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 22:23 - AWFORD"]
-            #[inline]
-            pub fn awford(&mut self) -> _AWFORDW {
-                _AWFORDW { w: self }
-            }
-            #[doc = "Bits 16:20 - AWFOSR"]
-            #[inline]
-            pub fn awfosr(&mut self) -> _AWFOSRW {
-                _AWFOSRW { w: self }
-            }
-            #[doc = "Bits 12:15 - BKSCD"]
-            #[inline]
-            pub fn bkscd(&mut self) -> _BKSCDW {
-                _BKSCDW { w: self }
-            }
-            #[doc = "Bits 0:7 - SCDT"]
-            #[inline]
-            pub fn scdt(&mut self) -> _SCDTW {
-                _SCDTW { w: self }
-            }
-        }
-    }
-    #[doc = "CHWDAT7R"]
-    pub struct CH7WDATR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHWDAT7R"]
-    pub mod ch7wdatr {
-        #[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::CH7WDATR {
-            #[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 = r" Value of the field"]
-        pub struct WDATAR {
-            bits: u16,
-        }
-        impl WDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&self) -> WDATAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                WDATAR { bits }
-            }
-        }
-        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 0:15 - WDATA"]
-            #[inline]
-            pub fn wdata(&mut self) -> _WDATAW {
-                _WDATAW { w: self }
-            }
-        }
-    }
-    #[doc = "CHDATIN7R"]
-    pub struct CH7DATINR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "CHDATIN7R"]
-    pub mod ch7datinr {
-        #[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::CH7DATINR {
-            #[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 = r" Value of the field"]
-        pub struct INDAT1R {
-            bits: u16,
-        }
-        impl INDAT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INDAT0R {
-            bits: u16,
-        }
-        impl INDAT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INDAT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INDAT0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&self) -> INDAT1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT1R { bits }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&self) -> INDAT0R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INDAT0R { bits }
-            }
-        }
-        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 16:31 - INDAT1"]
-            #[inline]
-            pub fn indat1(&mut self) -> _INDAT1W {
-                _INDAT1W { w: self }
-            }
-            #[doc = "Bits 0:15 - INDAT0"]
-            #[inline]
-            pub fn indat0(&mut self) -> _INDAT0W {
-                _INDAT0W { w: self }
-            }
-        }
-    }
-    #[doc = "control register 1"]
-    pub struct FLT0CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod flt0cr1 {
-        #[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::FLT0CR1 {
-            #[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 = r" Value of the field"]
-        pub struct AWFSELR {
-            bits: bool,
-        }
-        impl AWFSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FASTR {
-            bits: bool,
-        }
-        impl FASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCHR {
-            bits: u8,
-        }
-        impl RCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RDMAENR {
-            bits: bool,
-        }
-        impl RDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSYNCR {
-            bits: bool,
-        }
-        impl RSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCONTR {
-            bits: bool,
-        }
-        impl RCONTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSWSTARTR {
-            bits: bool,
-        }
-        impl RSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEXTENR {
-            bits: u8,
-        }
-        impl JEXTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JEXTSELR {
-            bits: u8,
-        }
-        impl JEXTSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDMAENR {
-            bits: bool,
-        }
-        impl JDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSCANR {
-            bits: bool,
-        }
-        impl JSCANR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSYNCR {
-            bits: bool,
-        }
-        impl JSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSWSTARTR {
-            bits: bool,
-        }
-        impl JSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFENR {
-            bits: bool,
-        }
-        impl DFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWFSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FASTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCONTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCONTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEXTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JEXTSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSCANW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSCANW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 30 - Analog watchdog fast mode select"]
-            #[inline]
-            pub fn awfsel(&self) -> AWFSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWFSELR { bits }
-            }
-            #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"]
-            #[inline]
-            pub fn fast(&self) -> FASTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FASTR { bits }
-            }
-            #[doc = "Bits 24:26 - Regular channel selection"]
-            #[inline]
-            pub fn rch(&self) -> RCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RCHR { bits }
-            }
-            #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"]
-            #[inline]
-            pub fn rdmaen(&self) -> RDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RDMAENR { bits }
-            }
-            #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"]
-            #[inline]
-            pub fn rsync(&self) -> RSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSYNCR { bits }
-            }
-            #[doc = "Bit 18 - Continuous mode selection for regular conversions"]
-            #[inline]
-            pub fn rcont(&self) -> RCONTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCONTR { bits }
-            }
-            #[doc = "Bit 17 - Software start of a conversion on the regular channel"]
-            #[inline]
-            pub fn rswstart(&self) -> RSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSWSTARTR { bits }
-            }
-            # [ doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions" ] # [ inline ]
-            pub fn jexten(&self) -> JEXTENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTENR { bits }
-            }
-            #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"]
-            #[inline]
-            pub fn jextsel(&self) -> JEXTSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTSELR { bits }
-            }
-            #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"]
-            #[inline]
-            pub fn jdmaen(&self) -> JDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JDMAENR { bits }
-            }
-            #[doc = "Bit 4 - Scanning conversion mode for injected conversions"]
-            #[inline]
-            pub fn jscan(&self) -> JSCANR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSCANR { bits }
-            }
-            # [ doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger" ] # [ inline ]
-            pub fn jsync(&self) -> JSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSYNCR { bits }
-            }
-            #[doc = "Bit 1 - Start a conversion of the injected group of channels"]
-            #[inline]
-            pub fn jswstart(&self) -> JSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSWSTARTR { bits }
-            }
-            #[doc = "Bit 0 - DFSDM enable"]
-            #[inline]
-            pub fn dfen(&self) -> DFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFENR { bits }
-            }
-        }
-        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 30 - Analog watchdog fast mode select"]
-            #[inline]
-            pub fn awfsel(&mut self) -> _AWFSELW {
-                _AWFSELW { w: self }
-            }
-            #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"]
-            #[inline]
-            pub fn fast(&mut self) -> _FASTW {
-                _FASTW { w: self }
-            }
-            #[doc = "Bits 24:26 - Regular channel selection"]
-            #[inline]
-            pub fn rch(&mut self) -> _RCHW {
-                _RCHW { w: self }
-            }
-            #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"]
-            #[inline]
-            pub fn rdmaen(&mut self) -> _RDMAENW {
-                _RDMAENW { w: self }
-            }
-            #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"]
-            #[inline]
-            pub fn rsync(&mut self) -> _RSYNCW {
-                _RSYNCW { w: self }
-            }
-            #[doc = "Bit 18 - Continuous mode selection for regular conversions"]
-            #[inline]
-            pub fn rcont(&mut self) -> _RCONTW {
-                _RCONTW { w: self }
-            }
-            #[doc = "Bit 17 - Software start of a conversion on the regular channel"]
-            #[inline]
-            pub fn rswstart(&mut self) -> _RSWSTARTW {
-                _RSWSTARTW { w: self }
-            }
-            # [ doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions" ] # [ inline ]
-            pub fn jexten(&mut self) -> _JEXTENW {
-                _JEXTENW { w: self }
-            }
-            #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"]
-            #[inline]
-            pub fn jextsel(&mut self) -> _JEXTSELW {
-                _JEXTSELW { w: self }
-            }
-            #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"]
-            #[inline]
-            pub fn jdmaen(&mut self) -> _JDMAENW {
-                _JDMAENW { w: self }
-            }
-            #[doc = "Bit 4 - Scanning conversion mode for injected conversions"]
-            #[inline]
-            pub fn jscan(&mut self) -> _JSCANW {
-                _JSCANW { w: self }
-            }
-            # [ doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger" ] # [ inline ]
-            pub fn jsync(&mut self) -> _JSYNCW {
-                _JSYNCW { w: self }
-            }
-            #[doc = "Bit 1 - Start a conversion of the injected group of channels"]
-            #[inline]
-            pub fn jswstart(&mut self) -> _JSWSTARTW {
-                _JSWSTARTW { w: self }
-            }
-            #[doc = "Bit 0 - DFSDM enable"]
-            #[inline]
-            pub fn dfen(&mut self) -> _DFENW {
-                _DFENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct FLT0CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod flt0cr2 {
-        #[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::FLT0CR2 {
-            #[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 = r" Value of the field"]
-        pub struct AWDCHR {
-            bits: u8,
-        }
-        impl AWDCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXCHR {
-            bits: u8,
-        }
-        impl EXCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKABIER {
-            bits: bool,
-        }
-        impl CKABIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDIER {
-            bits: bool,
-        }
-        impl SCDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDIER {
-            bits: bool,
-        }
-        impl AWDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ROVRIER {
-            bits: bool,
-        }
-        impl ROVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JOVRIER {
-            bits: bool,
-        }
-        impl JOVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REOCIER {
-            bits: bool,
-        }
-        impl REOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCIER {
-            bits: bool,
-        }
-        impl JEOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWDCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKABIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ROVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ROVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JOVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JOVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _REOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _REOCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEOCIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:23 - Analog watchdog channel selection"]
-            #[inline]
-            pub fn awdch(&self) -> AWDCHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWDCHR { bits }
-            }
-            #[doc = "Bits 8:15 - Extremes detector channel selection"]
-            #[inline]
-            pub fn exch(&self) -> EXCHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXCHR { bits }
-            }
-            #[doc = "Bit 6 - Clock absence interrupt enable"]
-            #[inline]
-            pub fn ckabie(&self) -> CKABIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABIER { bits }
-            }
-            #[doc = "Bit 5 - Short-circuit detector interrupt enable"]
-            #[inline]
-            pub fn scdie(&self) -> SCDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDIER { bits }
-            }
-            #[doc = "Bit 4 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&self) -> AWDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDIER { bits }
-            }
-            #[doc = "Bit 3 - Regular data overrun interrupt enable"]
-            #[inline]
-            pub fn rovrie(&self) -> ROVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ROVRIER { bits }
-            }
-            #[doc = "Bit 2 - Injected data overrun interrupt enable"]
-            #[inline]
-            pub fn jovrie(&self) -> JOVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JOVRIER { bits }
-            }
-            #[doc = "Bit 1 - Regular end of conversion interrupt enable"]
-            #[inline]
-            pub fn reocie(&self) -> REOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REOCIER { bits }
-            }
-            #[doc = "Bit 0 - Injected end of conversion interrupt enable"]
-            #[inline]
-            pub fn jeocie(&self) -> JEOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCIER { bits }
-            }
-        }
-        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 16:23 - Analog watchdog channel selection"]
-            #[inline]
-            pub fn awdch(&mut self) -> _AWDCHW {
-                _AWDCHW { w: self }
-            }
-            #[doc = "Bits 8:15 - Extremes detector channel selection"]
-            #[inline]
-            pub fn exch(&mut self) -> _EXCHW {
-                _EXCHW { w: self }
-            }
-            #[doc = "Bit 6 - Clock absence interrupt enable"]
-            #[inline]
-            pub fn ckabie(&mut self) -> _CKABIEW {
-                _CKABIEW { w: self }
-            }
-            #[doc = "Bit 5 - Short-circuit detector interrupt enable"]
-            #[inline]
-            pub fn scdie(&mut self) -> _SCDIEW {
-                _SCDIEW { w: self }
-            }
-            #[doc = "Bit 4 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&mut self) -> _AWDIEW {
-                _AWDIEW { w: self }
-            }
-            #[doc = "Bit 3 - Regular data overrun interrupt enable"]
-            #[inline]
-            pub fn rovrie(&mut self) -> _ROVRIEW {
-                _ROVRIEW { w: self }
-            }
-            #[doc = "Bit 2 - Injected data overrun interrupt enable"]
-            #[inline]
-            pub fn jovrie(&mut self) -> _JOVRIEW {
-                _JOVRIEW { w: self }
-            }
-            #[doc = "Bit 1 - Regular end of conversion interrupt enable"]
-            #[inline]
-            pub fn reocie(&mut self) -> _REOCIEW {
-                _REOCIEW { w: self }
-            }
-            #[doc = "Bit 0 - Injected end of conversion interrupt enable"]
-            #[inline]
-            pub fn jeocie(&mut self) -> _JEOCIEW {
-                _JEOCIEW { w: self }
-            }
-        }
-    }
-    #[doc = "interrupt and status register"]
-    pub struct FLT0ISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt and status register"]
-    pub mod flt0isr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT0ISR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDFR {
-            bits: u8,
-        }
-        impl SCDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKABFR {
-            bits: u8,
-        }
-        impl CKABFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RCIPR {
-            bits: bool,
-        }
-        impl RCIPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JCIPR {
-            bits: bool,
-        }
-        impl JCIPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDFR {
-            bits: bool,
-        }
-        impl AWDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ROVRFR {
-            bits: bool,
-        }
-        impl ROVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JOVRFR {
-            bits: bool,
-        }
-        impl JOVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REOCFR {
-            bits: bool,
-        }
-        impl REOCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCFR {
-            bits: bool,
-        }
-        impl JEOCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - short-circuit detector flag"]
-            #[inline]
-            pub fn scdf(&self) -> SCDFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDFR { bits }
-            }
-            #[doc = "Bits 16:23 - Clock absence flag"]
-            #[inline]
-            pub fn ckabf(&self) -> CKABFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKABFR { bits }
-            }
-            #[doc = "Bit 14 - Regular conversion in progress status"]
-            #[inline]
-            pub fn rcip(&self) -> RCIPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCIPR { bits }
-            }
-            #[doc = "Bit 13 - Injected conversion in progress status"]
-            #[inline]
-            pub fn jcip(&self) -> JCIPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JCIPR { bits }
-            }
-            #[doc = "Bit 4 - Analog watchdog"]
-            #[inline]
-            pub fn awdf(&self) -> AWDFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDFR { bits }
-            }
-            #[doc = "Bit 3 - Regular conversion overrun flag"]
-            #[inline]
-            pub fn rovrf(&self) -> ROVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ROVRFR { bits }
-            }
-            #[doc = "Bit 2 - Injected conversion overrun flag"]
-            #[inline]
-            pub fn jovrf(&self) -> JOVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JOVRFR { bits }
-            }
-            #[doc = "Bit 1 - End of regular conversion flag"]
-            #[inline]
-            pub fn reocf(&self) -> REOCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REOCFR { bits }
-            }
-            #[doc = "Bit 0 - End of injected conversion flag"]
-            #[inline]
-            pub fn jeocf(&self) -> JEOCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCFR { bits }
-            }
-        }
-    }
-    #[doc = "interrupt flag clear register"]
-    pub struct FLT0ICR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt flag clear register"]
-    pub mod flt0icr {
-        #[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::FLT0ICR {
-            #[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 = r" Value of the field"]
-        pub struct CLRSCDFR {
-            bits: u8,
-        }
-        impl CLRSCDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRCKABFR {
-            bits: u8,
-        }
-        impl CLRCKABFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRROVRFR {
-            bits: bool,
-        }
-        impl CLRROVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CLRJOVRFR {
-            bits: bool,
-        }
-        impl CLRJOVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CLRSCDFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRSCDFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRCKABFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRCKABFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRROVRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRROVRFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CLRJOVRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRJOVRFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - Clear the short-circuit detector flag"]
-            #[inline]
-            pub fn clrscdf(&self) -> CLRSCDFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRSCDFR { bits }
-            }
-            #[doc = "Bits 16:23 - Clear the clock absence flag"]
-            #[inline]
-            pub fn clrckabf(&self) -> CLRCKABFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRCKABFR { bits }
-            }
-            #[doc = "Bit 3 - Clear the regular conversion overrun flag"]
-            #[inline]
-            pub fn clrrovrf(&self) -> CLRROVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLRROVRFR { bits }
-            }
-            #[doc = "Bit 2 - Clear the injected conversion overrun flag"]
-            #[inline]
-            pub fn clrjovrf(&self) -> CLRJOVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLRJOVRFR { bits }
-            }
-        }
-        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 24:31 - Clear the short-circuit detector flag"]
-            #[inline]
-            pub fn clrscdf(&mut self) -> _CLRSCDFW {
-                _CLRSCDFW { w: self }
-            }
-            #[doc = "Bits 16:23 - Clear the clock absence flag"]
-            #[inline]
-            pub fn clrckabf(&mut self) -> _CLRCKABFW {
-                _CLRCKABFW { w: self }
-            }
-            #[doc = "Bit 3 - Clear the regular conversion overrun flag"]
-            #[inline]
-            pub fn clrrovrf(&mut self) -> _CLRROVRFW {
-                _CLRROVRFW { w: self }
-            }
-            #[doc = "Bit 2 - Clear the injected conversion overrun flag"]
-            #[inline]
-            pub fn clrjovrf(&mut self) -> _CLRJOVRFW {
-                _CLRJOVRFW { w: self }
-            }
-        }
-    }
-    #[doc = "injected channel group selection register"]
-    pub struct FLT0JCHGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "injected channel group selection register"]
-    pub mod flt0jchgr {
-        #[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::FLT0JCHGR {
-            #[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 = r" Value of the field"]
-        pub struct JCHGR {
-            bits: u8,
-        }
-        impl JCHGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JCHGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JCHGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - Injected channel group selection"]
-            #[inline]
-            pub fn jchg(&self) -> JCHGR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JCHGR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x01 }
-            }
-            #[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 0:7 - Injected channel group selection"]
-            #[inline]
-            pub fn jchg(&mut self) -> _JCHGW {
-                _JCHGW { w: self }
-            }
-        }
-    }
-    #[doc = "filter control register"]
-    pub struct FLT0FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter control register"]
-    pub mod flt0fcr {
-        #[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::FLT0FCR {
-            #[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 = r" Value of the field"]
-        pub struct FORDR {
-            bits: u8,
-        }
-        impl FORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FOSRR {
-            bits: u16,
-        }
-        impl FOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IOSRR {
-            bits: u8,
-        }
-        impl IOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 29:31 - Sinc filter order"]
-            #[inline]
-            pub fn ford(&self) -> FORDR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FORDR { bits }
-            }
-            #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"]
-            #[inline]
-            pub fn fosr(&self) -> FOSRR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                FOSRR { bits }
-            }
-            #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"]
-            #[inline]
-            pub fn iosr(&self) -> IOSRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IOSRR { bits }
-            }
-        }
-        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 29:31 - Sinc filter order"]
-            #[inline]
-            pub fn ford(&mut self) -> _FORDW {
-                _FORDW { w: self }
-            }
-            #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"]
-            #[inline]
-            pub fn fosr(&mut self) -> _FOSRW {
-                _FOSRW { w: self }
-            }
-            #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"]
-            #[inline]
-            pub fn iosr(&mut self) -> _IOSRW {
-                _IOSRW { w: self }
-            }
-        }
-    }
-    #[doc = "data register for injected group"]
-    pub struct FLT0JDATAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register for injected group"]
-    pub mod flt0jdatar {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT0JDATAR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATAR {
-            bits: u32,
-        }
-        impl JDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATACHR {
-            bits: u8,
-        }
-        impl JDATACHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Injected group conversion data"]
-            #[inline]
-            pub fn jdata(&self) -> JDATAR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                JDATAR { bits }
-            }
-            #[doc = "Bits 0:2 - Injected channel most recently converted"]
-            #[inline]
-            pub fn jdatach(&self) -> JDATACHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JDATACHR { bits }
-            }
-        }
-    }
-    #[doc = "data register for the regular channel"]
-    pub struct FLT0RDATAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register for the regular channel"]
-    pub mod flt0rdatar {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT0RDATAR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RDATAR {
-            bits: u32,
-        }
-        impl RDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RPENDR {
-            bits: bool,
-        }
-        impl RPENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RDATACHR {
-            bits: u8,
-        }
-        impl RDATACHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Regular channel conversion data"]
-            #[inline]
-            pub fn rdata(&self) -> RDATAR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                RDATAR { bits }
-            }
-            #[doc = "Bit 4 - Regular channel pending data"]
-            #[inline]
-            pub fn rpend(&self) -> RPENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RPENDR { bits }
-            }
-            #[doc = "Bits 0:2 - Regular channel most recently converted"]
-            #[inline]
-            pub fn rdatach(&self) -> RDATACHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RDATACHR { bits }
-            }
-        }
-    }
-    #[doc = "analog watchdog high threshold register"]
-    pub struct FLT0AWHTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog high threshold register"]
-    pub mod flt0awhtr {
-        #[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::FLT0AWHTR {
-            #[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 = r" Value of the field"]
-        pub struct AWHTR {
-            bits: u32,
-        }
-        impl AWHTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKAWHR {
-            bits: u8,
-        }
-        impl BKAWHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWHTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWHTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKAWHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKAWHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 8:31 - Analog watchdog high threshold"]
-            #[inline]
-            pub fn awht(&self) -> AWHTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AWHTR { bits }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"]
-            #[inline]
-            pub fn bkawh(&self) -> BKAWHR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKAWHR { bits }
-            }
-        }
-        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 8:31 - Analog watchdog high threshold"]
-            #[inline]
-            pub fn awht(&mut self) -> _AWHTW {
-                _AWHTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"]
-            #[inline]
-            pub fn bkawh(&mut self) -> _BKAWHW {
-                _BKAWHW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog low threshold register"]
-    pub struct FLT0AWLTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog low threshold register"]
-    pub mod flt0awltr {
-        #[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::FLT0AWLTR {
-            #[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 = r" Value of the field"]
-        pub struct AWLTR {
-            bits: u32,
-        }
-        impl AWLTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKAWLR {
-            bits: u8,
-        }
-        impl BKAWLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWLTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWLTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKAWLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKAWLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 8:31 - Analog watchdog low threshold"]
-            #[inline]
-            pub fn awlt(&self) -> AWLTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AWLTR { bits }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"]
-            #[inline]
-            pub fn bkawl(&self) -> BKAWLR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKAWLR { bits }
-            }
-        }
-        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 8:31 - Analog watchdog low threshold"]
-            #[inline]
-            pub fn awlt(&mut self) -> _AWLTW {
-                _AWLTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"]
-            #[inline]
-            pub fn bkawl(&mut self) -> _BKAWLW {
-                _BKAWLW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog status register"]
-    pub struct FLT0AWSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog status register"]
-    pub mod flt0awsr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT0AWSR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWHTFR {
-            bits: u8,
-        }
-        impl AWHTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWLTFR {
-            bits: u8,
-        }
-        impl AWLTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:15 - Analog watchdog high threshold flag"]
-            #[inline]
-            pub fn awhtf(&self) -> AWHTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWHTFR { bits }
-            }
-            #[doc = "Bits 0:7 - Analog watchdog low threshold flag"]
-            #[inline]
-            pub fn awltf(&self) -> AWLTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWLTFR { bits }
-            }
-        }
-    }
-    #[doc = "analog watchdog clear flag register"]
-    pub struct FLT0AWCFR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog clear flag register"]
-    pub mod flt0awcfr {
-        #[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::FLT0AWCFR {
-            #[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 = r" Value of the field"]
-        pub struct CLRAWHTFR {
-            bits: u8,
-        }
-        impl CLRAWHTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRAWLTFR {
-            bits: u8,
-        }
-        impl CLRAWLTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRAWHTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRAWHTFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRAWLTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRAWLTFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 8:15 - Clear the analog watchdog high threshold flag"]
-            #[inline]
-            pub fn clrawhtf(&self) -> CLRAWHTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRAWHTFR { bits }
-            }
-            #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"]
-            #[inline]
-            pub fn clrawltf(&self) -> CLRAWLTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRAWLTFR { bits }
-            }
-        }
-        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 8:15 - Clear the analog watchdog high threshold flag"]
-            #[inline]
-            pub fn clrawhtf(&mut self) -> _CLRAWHTFW {
-                _CLRAWHTFW { w: self }
-            }
-            #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"]
-            #[inline]
-            pub fn clrawltf(&mut self) -> _CLRAWLTFW {
-                _CLRAWLTFW { w: self }
-            }
-        }
-    }
-    #[doc = "Extremes detector maximum register"]
-    pub struct FLT0EXMAX {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Extremes detector maximum register"]
-    pub mod flt0exmax {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT0EXMAX {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMAXR {
-            bits: u32,
-        }
-        impl EXMAXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMAXCHR {
-            bits: u8,
-        }
-        impl EXMAXCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Extremes detector maximum value"]
-            #[inline]
-            pub fn exmax(&self) -> EXMAXR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXMAXR { bits }
-            }
-            #[doc = "Bits 0:2 - Extremes detector maximum data channel"]
-            #[inline]
-            pub fn exmaxch(&self) -> EXMAXCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXMAXCHR { bits }
-            }
-        }
-    }
-    #[doc = "Extremes detector minimum register"]
-    pub struct FLT0EXMIN {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Extremes detector minimum register"]
-    pub mod flt0exmin {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT0EXMIN {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMINR {
-            bits: u32,
-        }
-        impl EXMINR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMINCHR {
-            bits: u8,
-        }
-        impl EXMINCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - EXMIN"]
-            #[inline]
-            pub fn exmin(&self) -> EXMINR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXMINR { bits }
-            }
-            #[doc = "Bits 0:2 - Extremes detector minimum data channel"]
-            #[inline]
-            pub fn exminch(&self) -> EXMINCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXMINCHR { bits }
-            }
-        }
-    }
-    #[doc = "conversion timer register"]
-    pub struct FLT0CNVTIMR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "conversion timer register"]
-    pub mod flt0cnvtimr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT0CNVTIMR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CNVCNTR {
-            bits: u32,
-        }
-        impl CNVCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            # [ doc = "Bits 4:31 - 28-bit timer counting conversion time t = CNVCNT[27:0] / fDFSDM_CKIN" ] # [ inline ]
-            pub fn cnvcnt(&self) -> CNVCNTR {
-                let bits = {
-                    const MASK: u32 = 0x0fff_ffff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CNVCNTR { bits }
-            }
-        }
-    }
-    #[doc = "control register 1"]
-    pub struct FLT1CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod flt1cr1 {
-        #[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::FLT1CR1 {
-            #[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 = r" Value of the field"]
-        pub struct AWFSELR {
-            bits: bool,
-        }
-        impl AWFSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FASTR {
-            bits: bool,
-        }
-        impl FASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCHR {
-            bits: u8,
-        }
-        impl RCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RDMAENR {
-            bits: bool,
-        }
-        impl RDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSYNCR {
-            bits: bool,
-        }
-        impl RSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCONTR {
-            bits: bool,
-        }
-        impl RCONTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSWSTARTR {
-            bits: bool,
-        }
-        impl RSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEXTENR {
-            bits: u8,
-        }
-        impl JEXTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JEXTSELR {
-            bits: u8,
-        }
-        impl JEXTSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDMAENR {
-            bits: bool,
-        }
-        impl JDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSCANR {
-            bits: bool,
-        }
-        impl JSCANR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSYNCR {
-            bits: bool,
-        }
-        impl JSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSWSTARTR {
-            bits: bool,
-        }
-        impl JSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFENR {
-            bits: bool,
-        }
-        impl DFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWFSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FASTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCONTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCONTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEXTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JEXTSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSCANW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSCANW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 30 - Analog watchdog fast mode select"]
-            #[inline]
-            pub fn awfsel(&self) -> AWFSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWFSELR { bits }
-            }
-            #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"]
-            #[inline]
-            pub fn fast(&self) -> FASTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FASTR { bits }
-            }
-            #[doc = "Bits 24:26 - Regular channel selection"]
-            #[inline]
-            pub fn rch(&self) -> RCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RCHR { bits }
-            }
-            #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"]
-            #[inline]
-            pub fn rdmaen(&self) -> RDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RDMAENR { bits }
-            }
-            #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"]
-            #[inline]
-            pub fn rsync(&self) -> RSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSYNCR { bits }
-            }
-            #[doc = "Bit 18 - Continuous mode selection for regular conversions"]
-            #[inline]
-            pub fn rcont(&self) -> RCONTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCONTR { bits }
-            }
-            #[doc = "Bit 17 - Software start of a conversion on the regular channel"]
-            #[inline]
-            pub fn rswstart(&self) -> RSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSWSTARTR { bits }
-            }
-            # [ doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions" ] # [ inline ]
-            pub fn jexten(&self) -> JEXTENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTENR { bits }
-            }
-            #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"]
-            #[inline]
-            pub fn jextsel(&self) -> JEXTSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTSELR { bits }
-            }
-            #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"]
-            #[inline]
-            pub fn jdmaen(&self) -> JDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JDMAENR { bits }
-            }
-            #[doc = "Bit 4 - Scanning conversion mode for injected conversions"]
-            #[inline]
-            pub fn jscan(&self) -> JSCANR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSCANR { bits }
-            }
-            # [ doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger" ] # [ inline ]
-            pub fn jsync(&self) -> JSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSYNCR { bits }
-            }
-            #[doc = "Bit 1 - Start a conversion of the injected group of channels"]
-            #[inline]
-            pub fn jswstart(&self) -> JSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSWSTARTR { bits }
-            }
-            #[doc = "Bit 0 - DFSDM enable"]
-            #[inline]
-            pub fn dfen(&self) -> DFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFENR { bits }
-            }
-        }
-        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 30 - Analog watchdog fast mode select"]
-            #[inline]
-            pub fn awfsel(&mut self) -> _AWFSELW {
-                _AWFSELW { w: self }
-            }
-            #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"]
-            #[inline]
-            pub fn fast(&mut self) -> _FASTW {
-                _FASTW { w: self }
-            }
-            #[doc = "Bits 24:26 - Regular channel selection"]
-            #[inline]
-            pub fn rch(&mut self) -> _RCHW {
-                _RCHW { w: self }
-            }
-            #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"]
-            #[inline]
-            pub fn rdmaen(&mut self) -> _RDMAENW {
-                _RDMAENW { w: self }
-            }
-            #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"]
-            #[inline]
-            pub fn rsync(&mut self) -> _RSYNCW {
-                _RSYNCW { w: self }
-            }
-            #[doc = "Bit 18 - Continuous mode selection for regular conversions"]
-            #[inline]
-            pub fn rcont(&mut self) -> _RCONTW {
-                _RCONTW { w: self }
-            }
-            #[doc = "Bit 17 - Software start of a conversion on the regular channel"]
-            #[inline]
-            pub fn rswstart(&mut self) -> _RSWSTARTW {
-                _RSWSTARTW { w: self }
-            }
-            # [ doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions" ] # [ inline ]
-            pub fn jexten(&mut self) -> _JEXTENW {
-                _JEXTENW { w: self }
-            }
-            #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"]
-            #[inline]
-            pub fn jextsel(&mut self) -> _JEXTSELW {
-                _JEXTSELW { w: self }
-            }
-            #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"]
-            #[inline]
-            pub fn jdmaen(&mut self) -> _JDMAENW {
-                _JDMAENW { w: self }
-            }
-            #[doc = "Bit 4 - Scanning conversion mode for injected conversions"]
-            #[inline]
-            pub fn jscan(&mut self) -> _JSCANW {
-                _JSCANW { w: self }
-            }
-            # [ doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger" ] # [ inline ]
-            pub fn jsync(&mut self) -> _JSYNCW {
-                _JSYNCW { w: self }
-            }
-            #[doc = "Bit 1 - Start a conversion of the injected group of channels"]
-            #[inline]
-            pub fn jswstart(&mut self) -> _JSWSTARTW {
-                _JSWSTARTW { w: self }
-            }
-            #[doc = "Bit 0 - DFSDM enable"]
-            #[inline]
-            pub fn dfen(&mut self) -> _DFENW {
-                _DFENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct FLT1CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod flt1cr2 {
-        #[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::FLT1CR2 {
-            #[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 = r" Value of the field"]
-        pub struct AWDCHR {
-            bits: u8,
-        }
-        impl AWDCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXCHR {
-            bits: u8,
-        }
-        impl EXCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKABIER {
-            bits: bool,
-        }
-        impl CKABIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDIER {
-            bits: bool,
-        }
-        impl SCDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDIER {
-            bits: bool,
-        }
-        impl AWDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ROVRIER {
-            bits: bool,
-        }
-        impl ROVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JOVRIER {
-            bits: bool,
-        }
-        impl JOVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REOCIER {
-            bits: bool,
-        }
-        impl REOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCIER {
-            bits: bool,
-        }
-        impl JEOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWDCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKABIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ROVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ROVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JOVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JOVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _REOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _REOCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEOCIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:23 - Analog watchdog channel selection"]
-            #[inline]
-            pub fn awdch(&self) -> AWDCHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWDCHR { bits }
-            }
-            #[doc = "Bits 8:15 - Extremes detector channel selection"]
-            #[inline]
-            pub fn exch(&self) -> EXCHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXCHR { bits }
-            }
-            #[doc = "Bit 6 - Clock absence interrupt enable"]
-            #[inline]
-            pub fn ckabie(&self) -> CKABIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABIER { bits }
-            }
-            #[doc = "Bit 5 - Short-circuit detector interrupt enable"]
-            #[inline]
-            pub fn scdie(&self) -> SCDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDIER { bits }
-            }
-            #[doc = "Bit 4 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&self) -> AWDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDIER { bits }
-            }
-            #[doc = "Bit 3 - Regular data overrun interrupt enable"]
-            #[inline]
-            pub fn rovrie(&self) -> ROVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ROVRIER { bits }
-            }
-            #[doc = "Bit 2 - Injected data overrun interrupt enable"]
-            #[inline]
-            pub fn jovrie(&self) -> JOVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JOVRIER { bits }
-            }
-            #[doc = "Bit 1 - Regular end of conversion interrupt enable"]
-            #[inline]
-            pub fn reocie(&self) -> REOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REOCIER { bits }
-            }
-            #[doc = "Bit 0 - Injected end of conversion interrupt enable"]
-            #[inline]
-            pub fn jeocie(&self) -> JEOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCIER { bits }
-            }
-        }
-        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 16:23 - Analog watchdog channel selection"]
-            #[inline]
-            pub fn awdch(&mut self) -> _AWDCHW {
-                _AWDCHW { w: self }
-            }
-            #[doc = "Bits 8:15 - Extremes detector channel selection"]
-            #[inline]
-            pub fn exch(&mut self) -> _EXCHW {
-                _EXCHW { w: self }
-            }
-            #[doc = "Bit 6 - Clock absence interrupt enable"]
-            #[inline]
-            pub fn ckabie(&mut self) -> _CKABIEW {
-                _CKABIEW { w: self }
-            }
-            #[doc = "Bit 5 - Short-circuit detector interrupt enable"]
-            #[inline]
-            pub fn scdie(&mut self) -> _SCDIEW {
-                _SCDIEW { w: self }
-            }
-            #[doc = "Bit 4 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&mut self) -> _AWDIEW {
-                _AWDIEW { w: self }
-            }
-            #[doc = "Bit 3 - Regular data overrun interrupt enable"]
-            #[inline]
-            pub fn rovrie(&mut self) -> _ROVRIEW {
-                _ROVRIEW { w: self }
-            }
-            #[doc = "Bit 2 - Injected data overrun interrupt enable"]
-            #[inline]
-            pub fn jovrie(&mut self) -> _JOVRIEW {
-                _JOVRIEW { w: self }
-            }
-            #[doc = "Bit 1 - Regular end of conversion interrupt enable"]
-            #[inline]
-            pub fn reocie(&mut self) -> _REOCIEW {
-                _REOCIEW { w: self }
-            }
-            #[doc = "Bit 0 - Injected end of conversion interrupt enable"]
-            #[inline]
-            pub fn jeocie(&mut self) -> _JEOCIEW {
-                _JEOCIEW { w: self }
-            }
-        }
-    }
-    #[doc = "interrupt and status register"]
-    pub struct FLT1ISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt and status register"]
-    pub mod flt1isr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT1ISR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDFR {
-            bits: u8,
-        }
-        impl SCDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKABFR {
-            bits: u8,
-        }
-        impl CKABFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RCIPR {
-            bits: bool,
-        }
-        impl RCIPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JCIPR {
-            bits: bool,
-        }
-        impl JCIPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDFR {
-            bits: bool,
-        }
-        impl AWDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ROVRFR {
-            bits: bool,
-        }
-        impl ROVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JOVRFR {
-            bits: bool,
-        }
-        impl JOVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REOCFR {
-            bits: bool,
-        }
-        impl REOCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCFR {
-            bits: bool,
-        }
-        impl JEOCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - short-circuit detector flag"]
-            #[inline]
-            pub fn scdf(&self) -> SCDFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDFR { bits }
-            }
-            #[doc = "Bits 16:23 - Clock absence flag"]
-            #[inline]
-            pub fn ckabf(&self) -> CKABFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKABFR { bits }
-            }
-            #[doc = "Bit 14 - Regular conversion in progress status"]
-            #[inline]
-            pub fn rcip(&self) -> RCIPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCIPR { bits }
-            }
-            #[doc = "Bit 13 - Injected conversion in progress status"]
-            #[inline]
-            pub fn jcip(&self) -> JCIPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JCIPR { bits }
-            }
-            #[doc = "Bit 4 - Analog watchdog"]
-            #[inline]
-            pub fn awdf(&self) -> AWDFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDFR { bits }
-            }
-            #[doc = "Bit 3 - Regular conversion overrun flag"]
-            #[inline]
-            pub fn rovrf(&self) -> ROVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ROVRFR { bits }
-            }
-            #[doc = "Bit 2 - Injected conversion overrun flag"]
-            #[inline]
-            pub fn jovrf(&self) -> JOVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JOVRFR { bits }
-            }
-            #[doc = "Bit 1 - End of regular conversion flag"]
-            #[inline]
-            pub fn reocf(&self) -> REOCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REOCFR { bits }
-            }
-            #[doc = "Bit 0 - End of injected conversion flag"]
-            #[inline]
-            pub fn jeocf(&self) -> JEOCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCFR { bits }
-            }
-        }
-    }
-    #[doc = "interrupt flag clear register"]
-    pub struct FLT1ICR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt flag clear register"]
-    pub mod flt1icr {
-        #[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::FLT1ICR {
-            #[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 = r" Value of the field"]
-        pub struct CLRSCDFR {
-            bits: u8,
-        }
-        impl CLRSCDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRCKABFR {
-            bits: u8,
-        }
-        impl CLRCKABFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRROVRFR {
-            bits: bool,
-        }
-        impl CLRROVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CLRJOVRFR {
-            bits: bool,
-        }
-        impl CLRJOVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CLRSCDFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRSCDFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRCKABFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRCKABFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRROVRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRROVRFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CLRJOVRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRJOVRFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - Clear the short-circuit detector flag"]
-            #[inline]
-            pub fn clrscdf(&self) -> CLRSCDFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRSCDFR { bits }
-            }
-            #[doc = "Bits 16:23 - Clear the clock absence flag"]
-            #[inline]
-            pub fn clrckabf(&self) -> CLRCKABFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRCKABFR { bits }
-            }
-            #[doc = "Bit 3 - Clear the regular conversion overrun flag"]
-            #[inline]
-            pub fn clrrovrf(&self) -> CLRROVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLRROVRFR { bits }
-            }
-            #[doc = "Bit 2 - Clear the injected conversion overrun flag"]
-            #[inline]
-            pub fn clrjovrf(&self) -> CLRJOVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLRJOVRFR { bits }
-            }
-        }
-        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 24:31 - Clear the short-circuit detector flag"]
-            #[inline]
-            pub fn clrscdf(&mut self) -> _CLRSCDFW {
-                _CLRSCDFW { w: self }
-            }
-            #[doc = "Bits 16:23 - Clear the clock absence flag"]
-            #[inline]
-            pub fn clrckabf(&mut self) -> _CLRCKABFW {
-                _CLRCKABFW { w: self }
-            }
-            #[doc = "Bit 3 - Clear the regular conversion overrun flag"]
-            #[inline]
-            pub fn clrrovrf(&mut self) -> _CLRROVRFW {
-                _CLRROVRFW { w: self }
-            }
-            #[doc = "Bit 2 - Clear the injected conversion overrun flag"]
-            #[inline]
-            pub fn clrjovrf(&mut self) -> _CLRJOVRFW {
-                _CLRJOVRFW { w: self }
-            }
-        }
-    }
-    #[doc = "injected channel group selection register"]
-    pub struct FLT1JCHGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "injected channel group selection register"]
-    pub mod flt1jchgr {
-        #[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::FLT1JCHGR {
-            #[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 = r" Value of the field"]
-        pub struct JCHGR {
-            bits: u8,
-        }
-        impl JCHGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JCHGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JCHGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - Injected channel group selection"]
-            #[inline]
-            pub fn jchg(&self) -> JCHGR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JCHGR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x01 }
-            }
-            #[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 0:7 - Injected channel group selection"]
-            #[inline]
-            pub fn jchg(&mut self) -> _JCHGW {
-                _JCHGW { w: self }
-            }
-        }
-    }
-    #[doc = "filter control register"]
-    pub struct FLT1FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter control register"]
-    pub mod flt1fcr {
-        #[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::FLT1FCR {
-            #[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 = r" Value of the field"]
-        pub struct FORDR {
-            bits: u8,
-        }
-        impl FORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FOSRR {
-            bits: u16,
-        }
-        impl FOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IOSRR {
-            bits: u8,
-        }
-        impl IOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 29:31 - Sinc filter order"]
-            #[inline]
-            pub fn ford(&self) -> FORDR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FORDR { bits }
-            }
-            #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"]
-            #[inline]
-            pub fn fosr(&self) -> FOSRR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                FOSRR { bits }
-            }
-            #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"]
-            #[inline]
-            pub fn iosr(&self) -> IOSRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IOSRR { bits }
-            }
-        }
-        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 29:31 - Sinc filter order"]
-            #[inline]
-            pub fn ford(&mut self) -> _FORDW {
-                _FORDW { w: self }
-            }
-            #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"]
-            #[inline]
-            pub fn fosr(&mut self) -> _FOSRW {
-                _FOSRW { w: self }
-            }
-            #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"]
-            #[inline]
-            pub fn iosr(&mut self) -> _IOSRW {
-                _IOSRW { w: self }
-            }
-        }
-    }
-    #[doc = "data register for injected group"]
-    pub struct FLT1JDATAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register for injected group"]
-    pub mod flt1jdatar {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT1JDATAR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATAR {
-            bits: u32,
-        }
-        impl JDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATACHR {
-            bits: u8,
-        }
-        impl JDATACHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Injected group conversion data"]
-            #[inline]
-            pub fn jdata(&self) -> JDATAR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                JDATAR { bits }
-            }
-            #[doc = "Bits 0:2 - Injected channel most recently converted"]
-            #[inline]
-            pub fn jdatach(&self) -> JDATACHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JDATACHR { bits }
-            }
-        }
-    }
-    #[doc = "data register for the regular channel"]
-    pub struct FLT1RDATAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register for the regular channel"]
-    pub mod flt1rdatar {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT1RDATAR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RDATAR {
-            bits: u32,
-        }
-        impl RDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RPENDR {
-            bits: bool,
-        }
-        impl RPENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RDATACHR {
-            bits: u8,
-        }
-        impl RDATACHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Regular channel conversion data"]
-            #[inline]
-            pub fn rdata(&self) -> RDATAR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                RDATAR { bits }
-            }
-            #[doc = "Bit 4 - Regular channel pending data"]
-            #[inline]
-            pub fn rpend(&self) -> RPENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RPENDR { bits }
-            }
-            #[doc = "Bits 0:2 - Regular channel most recently converted"]
-            #[inline]
-            pub fn rdatach(&self) -> RDATACHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RDATACHR { bits }
-            }
-        }
-    }
-    #[doc = "analog watchdog high threshold register"]
-    pub struct FLT1AWHTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog high threshold register"]
-    pub mod flt1awhtr {
-        #[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::FLT1AWHTR {
-            #[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 = r" Value of the field"]
-        pub struct AWHTR {
-            bits: u32,
-        }
-        impl AWHTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKAWHR {
-            bits: u8,
-        }
-        impl BKAWHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWHTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWHTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKAWHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKAWHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 8:31 - Analog watchdog high threshold"]
-            #[inline]
-            pub fn awht(&self) -> AWHTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AWHTR { bits }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"]
-            #[inline]
-            pub fn bkawh(&self) -> BKAWHR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKAWHR { bits }
-            }
-        }
-        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 8:31 - Analog watchdog high threshold"]
-            #[inline]
-            pub fn awht(&mut self) -> _AWHTW {
-                _AWHTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"]
-            #[inline]
-            pub fn bkawh(&mut self) -> _BKAWHW {
-                _BKAWHW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog low threshold register"]
-    pub struct FLT1AWLTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog low threshold register"]
-    pub mod flt1awltr {
-        #[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::FLT1AWLTR {
-            #[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 = r" Value of the field"]
-        pub struct AWLTR {
-            bits: u32,
-        }
-        impl AWLTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKAWLR {
-            bits: u8,
-        }
-        impl BKAWLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWLTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWLTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKAWLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKAWLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 8:31 - Analog watchdog low threshold"]
-            #[inline]
-            pub fn awlt(&self) -> AWLTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AWLTR { bits }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"]
-            #[inline]
-            pub fn bkawl(&self) -> BKAWLR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKAWLR { bits }
-            }
-        }
-        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 8:31 - Analog watchdog low threshold"]
-            #[inline]
-            pub fn awlt(&mut self) -> _AWLTW {
-                _AWLTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"]
-            #[inline]
-            pub fn bkawl(&mut self) -> _BKAWLW {
-                _BKAWLW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog status register"]
-    pub struct FLT1AWSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog status register"]
-    pub mod flt1awsr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT1AWSR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWHTFR {
-            bits: u8,
-        }
-        impl AWHTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWLTFR {
-            bits: u8,
-        }
-        impl AWLTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:15 - Analog watchdog high threshold flag"]
-            #[inline]
-            pub fn awhtf(&self) -> AWHTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWHTFR { bits }
-            }
-            #[doc = "Bits 0:7 - Analog watchdog low threshold flag"]
-            #[inline]
-            pub fn awltf(&self) -> AWLTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWLTFR { bits }
-            }
-        }
-    }
-    #[doc = "analog watchdog clear flag register"]
-    pub struct FLT1AWCFR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog clear flag register"]
-    pub mod flt1awcfr {
-        #[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::FLT1AWCFR {
-            #[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 = r" Value of the field"]
-        pub struct CLRAWHTFR {
-            bits: u8,
-        }
-        impl CLRAWHTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRAWLTFR {
-            bits: u8,
-        }
-        impl CLRAWLTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRAWHTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRAWHTFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRAWLTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRAWLTFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 8:15 - Clear the analog watchdog high threshold flag"]
-            #[inline]
-            pub fn clrawhtf(&self) -> CLRAWHTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRAWHTFR { bits }
-            }
-            #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"]
-            #[inline]
-            pub fn clrawltf(&self) -> CLRAWLTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRAWLTFR { bits }
-            }
-        }
-        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 8:15 - Clear the analog watchdog high threshold flag"]
-            #[inline]
-            pub fn clrawhtf(&mut self) -> _CLRAWHTFW {
-                _CLRAWHTFW { w: self }
-            }
-            #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"]
-            #[inline]
-            pub fn clrawltf(&mut self) -> _CLRAWLTFW {
-                _CLRAWLTFW { w: self }
-            }
-        }
-    }
-    #[doc = "Extremes detector maximum register"]
-    pub struct FLT1EXMAX {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Extremes detector maximum register"]
-    pub mod flt1exmax {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT1EXMAX {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMAXR {
-            bits: u32,
-        }
-        impl EXMAXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMAXCHR {
-            bits: u8,
-        }
-        impl EXMAXCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Extremes detector maximum value"]
-            #[inline]
-            pub fn exmax(&self) -> EXMAXR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXMAXR { bits }
-            }
-            #[doc = "Bits 0:2 - Extremes detector maximum data channel"]
-            #[inline]
-            pub fn exmaxch(&self) -> EXMAXCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXMAXCHR { bits }
-            }
-        }
-    }
-    #[doc = "Extremes detector minimum register"]
-    pub struct FLT1EXMIN {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Extremes detector minimum register"]
-    pub mod flt1exmin {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT1EXMIN {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMINR {
-            bits: u32,
-        }
-        impl EXMINR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMINCHR {
-            bits: u8,
-        }
-        impl EXMINCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - EXMIN"]
-            #[inline]
-            pub fn exmin(&self) -> EXMINR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXMINR { bits }
-            }
-            #[doc = "Bits 0:2 - Extremes detector minimum data channel"]
-            #[inline]
-            pub fn exminch(&self) -> EXMINCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXMINCHR { bits }
-            }
-        }
-    }
-    #[doc = "conversion timer register"]
-    pub struct FLT1CNVTIMR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "conversion timer register"]
-    pub mod flt1cnvtimr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT1CNVTIMR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CNVCNTR {
-            bits: u32,
-        }
-        impl CNVCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            # [ doc = "Bits 4:31 - 28-bit timer counting conversion time t = CNVCNT[27:0] / fDFSDM_CKIN" ] # [ inline ]
-            pub fn cnvcnt(&self) -> CNVCNTR {
-                let bits = {
-                    const MASK: u32 = 0x0fff_ffff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CNVCNTR { bits }
-            }
-        }
-    }
-    #[doc = "control register 1"]
-    pub struct FLT2CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod flt2cr1 {
-        #[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::FLT2CR1 {
-            #[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 = r" Value of the field"]
-        pub struct AWFSELR {
-            bits: bool,
-        }
-        impl AWFSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FASTR {
-            bits: bool,
-        }
-        impl FASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCHR {
-            bits: u8,
-        }
-        impl RCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RDMAENR {
-            bits: bool,
-        }
-        impl RDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSYNCR {
-            bits: bool,
-        }
-        impl RSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCONTR {
-            bits: bool,
-        }
-        impl RCONTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSWSTARTR {
-            bits: bool,
-        }
-        impl RSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEXTENR {
-            bits: u8,
-        }
-        impl JEXTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JEXTSELR {
-            bits: u8,
-        }
-        impl JEXTSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDMAENR {
-            bits: bool,
-        }
-        impl JDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSCANR {
-            bits: bool,
-        }
-        impl JSCANR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSYNCR {
-            bits: bool,
-        }
-        impl JSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSWSTARTR {
-            bits: bool,
-        }
-        impl JSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFENR {
-            bits: bool,
-        }
-        impl DFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWFSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FASTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCONTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCONTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEXTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JEXTSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSCANW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSCANW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 30 - Analog watchdog fast mode select"]
-            #[inline]
-            pub fn awfsel(&self) -> AWFSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWFSELR { bits }
-            }
-            #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"]
-            #[inline]
-            pub fn fast(&self) -> FASTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FASTR { bits }
-            }
-            #[doc = "Bits 24:26 - Regular channel selection"]
-            #[inline]
-            pub fn rch(&self) -> RCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RCHR { bits }
-            }
-            #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"]
-            #[inline]
-            pub fn rdmaen(&self) -> RDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RDMAENR { bits }
-            }
-            #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"]
-            #[inline]
-            pub fn rsync(&self) -> RSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSYNCR { bits }
-            }
-            #[doc = "Bit 18 - Continuous mode selection for regular conversions"]
-            #[inline]
-            pub fn rcont(&self) -> RCONTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCONTR { bits }
-            }
-            #[doc = "Bit 17 - Software start of a conversion on the regular channel"]
-            #[inline]
-            pub fn rswstart(&self) -> RSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSWSTARTR { bits }
-            }
-            # [ doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions" ] # [ inline ]
-            pub fn jexten(&self) -> JEXTENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTENR { bits }
-            }
-            #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"]
-            #[inline]
-            pub fn jextsel(&self) -> JEXTSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTSELR { bits }
-            }
-            #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"]
-            #[inline]
-            pub fn jdmaen(&self) -> JDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JDMAENR { bits }
-            }
-            #[doc = "Bit 4 - Scanning conversion mode for injected conversions"]
-            #[inline]
-            pub fn jscan(&self) -> JSCANR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSCANR { bits }
-            }
-            # [ doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger" ] # [ inline ]
-            pub fn jsync(&self) -> JSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSYNCR { bits }
-            }
-            #[doc = "Bit 1 - Start a conversion of the injected group of channels"]
-            #[inline]
-            pub fn jswstart(&self) -> JSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSWSTARTR { bits }
-            }
-            #[doc = "Bit 0 - DFSDM enable"]
-            #[inline]
-            pub fn dfen(&self) -> DFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFENR { bits }
-            }
-        }
-        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 30 - Analog watchdog fast mode select"]
-            #[inline]
-            pub fn awfsel(&mut self) -> _AWFSELW {
-                _AWFSELW { w: self }
-            }
-            #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"]
-            #[inline]
-            pub fn fast(&mut self) -> _FASTW {
-                _FASTW { w: self }
-            }
-            #[doc = "Bits 24:26 - Regular channel selection"]
-            #[inline]
-            pub fn rch(&mut self) -> _RCHW {
-                _RCHW { w: self }
-            }
-            #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"]
-            #[inline]
-            pub fn rdmaen(&mut self) -> _RDMAENW {
-                _RDMAENW { w: self }
-            }
-            #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"]
-            #[inline]
-            pub fn rsync(&mut self) -> _RSYNCW {
-                _RSYNCW { w: self }
-            }
-            #[doc = "Bit 18 - Continuous mode selection for regular conversions"]
-            #[inline]
-            pub fn rcont(&mut self) -> _RCONTW {
-                _RCONTW { w: self }
-            }
-            #[doc = "Bit 17 - Software start of a conversion on the regular channel"]
-            #[inline]
-            pub fn rswstart(&mut self) -> _RSWSTARTW {
-                _RSWSTARTW { w: self }
-            }
-            # [ doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions" ] # [ inline ]
-            pub fn jexten(&mut self) -> _JEXTENW {
-                _JEXTENW { w: self }
-            }
-            #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"]
-            #[inline]
-            pub fn jextsel(&mut self) -> _JEXTSELW {
-                _JEXTSELW { w: self }
-            }
-            #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"]
-            #[inline]
-            pub fn jdmaen(&mut self) -> _JDMAENW {
-                _JDMAENW { w: self }
-            }
-            #[doc = "Bit 4 - Scanning conversion mode for injected conversions"]
-            #[inline]
-            pub fn jscan(&mut self) -> _JSCANW {
-                _JSCANW { w: self }
-            }
-            # [ doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger" ] # [ inline ]
-            pub fn jsync(&mut self) -> _JSYNCW {
-                _JSYNCW { w: self }
-            }
-            #[doc = "Bit 1 - Start a conversion of the injected group of channels"]
-            #[inline]
-            pub fn jswstart(&mut self) -> _JSWSTARTW {
-                _JSWSTARTW { w: self }
-            }
-            #[doc = "Bit 0 - DFSDM enable"]
-            #[inline]
-            pub fn dfen(&mut self) -> _DFENW {
-                _DFENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct FLT2CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod flt2cr2 {
-        #[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::FLT2CR2 {
-            #[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 = r" Value of the field"]
-        pub struct AWDCHR {
-            bits: u8,
-        }
-        impl AWDCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXCHR {
-            bits: u8,
-        }
-        impl EXCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKABIER {
-            bits: bool,
-        }
-        impl CKABIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDIER {
-            bits: bool,
-        }
-        impl SCDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDIER {
-            bits: bool,
-        }
-        impl AWDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ROVRIER {
-            bits: bool,
-        }
-        impl ROVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JOVRIER {
-            bits: bool,
-        }
-        impl JOVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REOCIER {
-            bits: bool,
-        }
-        impl REOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCIER {
-            bits: bool,
-        }
-        impl JEOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWDCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKABIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ROVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ROVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JOVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JOVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _REOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _REOCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEOCIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:23 - Analog watchdog channel selection"]
-            #[inline]
-            pub fn awdch(&self) -> AWDCHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWDCHR { bits }
-            }
-            #[doc = "Bits 8:15 - Extremes detector channel selection"]
-            #[inline]
-            pub fn exch(&self) -> EXCHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXCHR { bits }
-            }
-            #[doc = "Bit 6 - Clock absence interrupt enable"]
-            #[inline]
-            pub fn ckabie(&self) -> CKABIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABIER { bits }
-            }
-            #[doc = "Bit 5 - Short-circuit detector interrupt enable"]
-            #[inline]
-            pub fn scdie(&self) -> SCDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDIER { bits }
-            }
-            #[doc = "Bit 4 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&self) -> AWDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDIER { bits }
-            }
-            #[doc = "Bit 3 - Regular data overrun interrupt enable"]
-            #[inline]
-            pub fn rovrie(&self) -> ROVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ROVRIER { bits }
-            }
-            #[doc = "Bit 2 - Injected data overrun interrupt enable"]
-            #[inline]
-            pub fn jovrie(&self) -> JOVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JOVRIER { bits }
-            }
-            #[doc = "Bit 1 - Regular end of conversion interrupt enable"]
-            #[inline]
-            pub fn reocie(&self) -> REOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REOCIER { bits }
-            }
-            #[doc = "Bit 0 - Injected end of conversion interrupt enable"]
-            #[inline]
-            pub fn jeocie(&self) -> JEOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCIER { bits }
-            }
-        }
-        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 16:23 - Analog watchdog channel selection"]
-            #[inline]
-            pub fn awdch(&mut self) -> _AWDCHW {
-                _AWDCHW { w: self }
-            }
-            #[doc = "Bits 8:15 - Extremes detector channel selection"]
-            #[inline]
-            pub fn exch(&mut self) -> _EXCHW {
-                _EXCHW { w: self }
-            }
-            #[doc = "Bit 6 - Clock absence interrupt enable"]
-            #[inline]
-            pub fn ckabie(&mut self) -> _CKABIEW {
-                _CKABIEW { w: self }
-            }
-            #[doc = "Bit 5 - Short-circuit detector interrupt enable"]
-            #[inline]
-            pub fn scdie(&mut self) -> _SCDIEW {
-                _SCDIEW { w: self }
-            }
-            #[doc = "Bit 4 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&mut self) -> _AWDIEW {
-                _AWDIEW { w: self }
-            }
-            #[doc = "Bit 3 - Regular data overrun interrupt enable"]
-            #[inline]
-            pub fn rovrie(&mut self) -> _ROVRIEW {
-                _ROVRIEW { w: self }
-            }
-            #[doc = "Bit 2 - Injected data overrun interrupt enable"]
-            #[inline]
-            pub fn jovrie(&mut self) -> _JOVRIEW {
-                _JOVRIEW { w: self }
-            }
-            #[doc = "Bit 1 - Regular end of conversion interrupt enable"]
-            #[inline]
-            pub fn reocie(&mut self) -> _REOCIEW {
-                _REOCIEW { w: self }
-            }
-            #[doc = "Bit 0 - Injected end of conversion interrupt enable"]
-            #[inline]
-            pub fn jeocie(&mut self) -> _JEOCIEW {
-                _JEOCIEW { w: self }
-            }
-        }
-    }
-    #[doc = "interrupt and status register"]
-    pub struct FLT2ISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt and status register"]
-    pub mod flt2isr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT2ISR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDFR {
-            bits: u8,
-        }
-        impl SCDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKABFR {
-            bits: u8,
-        }
-        impl CKABFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RCIPR {
-            bits: bool,
-        }
-        impl RCIPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JCIPR {
-            bits: bool,
-        }
-        impl JCIPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDFR {
-            bits: bool,
-        }
-        impl AWDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ROVRFR {
-            bits: bool,
-        }
-        impl ROVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JOVRFR {
-            bits: bool,
-        }
-        impl JOVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REOCFR {
-            bits: bool,
-        }
-        impl REOCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCFR {
-            bits: bool,
-        }
-        impl JEOCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - short-circuit detector flag"]
-            #[inline]
-            pub fn scdf(&self) -> SCDFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDFR { bits }
-            }
-            #[doc = "Bits 16:23 - Clock absence flag"]
-            #[inline]
-            pub fn ckabf(&self) -> CKABFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKABFR { bits }
-            }
-            #[doc = "Bit 14 - Regular conversion in progress status"]
-            #[inline]
-            pub fn rcip(&self) -> RCIPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCIPR { bits }
-            }
-            #[doc = "Bit 13 - Injected conversion in progress status"]
-            #[inline]
-            pub fn jcip(&self) -> JCIPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JCIPR { bits }
-            }
-            #[doc = "Bit 4 - Analog watchdog"]
-            #[inline]
-            pub fn awdf(&self) -> AWDFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDFR { bits }
-            }
-            #[doc = "Bit 3 - Regular conversion overrun flag"]
-            #[inline]
-            pub fn rovrf(&self) -> ROVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ROVRFR { bits }
-            }
-            #[doc = "Bit 2 - Injected conversion overrun flag"]
-            #[inline]
-            pub fn jovrf(&self) -> JOVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JOVRFR { bits }
-            }
-            #[doc = "Bit 1 - End of regular conversion flag"]
-            #[inline]
-            pub fn reocf(&self) -> REOCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REOCFR { bits }
-            }
-            #[doc = "Bit 0 - End of injected conversion flag"]
-            #[inline]
-            pub fn jeocf(&self) -> JEOCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCFR { bits }
-            }
-        }
-    }
-    #[doc = "interrupt flag clear register"]
-    pub struct FLT2ICR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt flag clear register"]
-    pub mod flt2icr {
-        #[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::FLT2ICR {
-            #[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 = r" Value of the field"]
-        pub struct CLRSCDFR {
-            bits: u8,
-        }
-        impl CLRSCDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRCKABFR {
-            bits: u8,
-        }
-        impl CLRCKABFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRROVRFR {
-            bits: bool,
-        }
-        impl CLRROVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CLRJOVRFR {
-            bits: bool,
-        }
-        impl CLRJOVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CLRSCDFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRSCDFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRCKABFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRCKABFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRROVRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRROVRFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CLRJOVRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRJOVRFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - Clear the short-circuit detector flag"]
-            #[inline]
-            pub fn clrscdf(&self) -> CLRSCDFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRSCDFR { bits }
-            }
-            #[doc = "Bits 16:23 - Clear the clock absence flag"]
-            #[inline]
-            pub fn clrckabf(&self) -> CLRCKABFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRCKABFR { bits }
-            }
-            #[doc = "Bit 3 - Clear the regular conversion overrun flag"]
-            #[inline]
-            pub fn clrrovrf(&self) -> CLRROVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLRROVRFR { bits }
-            }
-            #[doc = "Bit 2 - Clear the injected conversion overrun flag"]
-            #[inline]
-            pub fn clrjovrf(&self) -> CLRJOVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLRJOVRFR { bits }
-            }
-        }
-        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 24:31 - Clear the short-circuit detector flag"]
-            #[inline]
-            pub fn clrscdf(&mut self) -> _CLRSCDFW {
-                _CLRSCDFW { w: self }
-            }
-            #[doc = "Bits 16:23 - Clear the clock absence flag"]
-            #[inline]
-            pub fn clrckabf(&mut self) -> _CLRCKABFW {
-                _CLRCKABFW { w: self }
-            }
-            #[doc = "Bit 3 - Clear the regular conversion overrun flag"]
-            #[inline]
-            pub fn clrrovrf(&mut self) -> _CLRROVRFW {
-                _CLRROVRFW { w: self }
-            }
-            #[doc = "Bit 2 - Clear the injected conversion overrun flag"]
-            #[inline]
-            pub fn clrjovrf(&mut self) -> _CLRJOVRFW {
-                _CLRJOVRFW { w: self }
-            }
-        }
-    }
-    #[doc = "injected channel group selection register"]
-    pub struct FLT2JCHGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "injected channel group selection register"]
-    pub mod flt2jchgr {
-        #[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::FLT2JCHGR {
-            #[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 = r" Value of the field"]
-        pub struct JCHGR {
-            bits: u8,
-        }
-        impl JCHGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JCHGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JCHGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - Injected channel group selection"]
-            #[inline]
-            pub fn jchg(&self) -> JCHGR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JCHGR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x01 }
-            }
-            #[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 0:7 - Injected channel group selection"]
-            #[inline]
-            pub fn jchg(&mut self) -> _JCHGW {
-                _JCHGW { w: self }
-            }
-        }
-    }
-    #[doc = "filter control register"]
-    pub struct FLT2FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter control register"]
-    pub mod flt2fcr {
-        #[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::FLT2FCR {
-            #[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 = r" Value of the field"]
-        pub struct FORDR {
-            bits: u8,
-        }
-        impl FORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FOSRR {
-            bits: u16,
-        }
-        impl FOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IOSRR {
-            bits: u8,
-        }
-        impl IOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 29:31 - Sinc filter order"]
-            #[inline]
-            pub fn ford(&self) -> FORDR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FORDR { bits }
-            }
-            #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"]
-            #[inline]
-            pub fn fosr(&self) -> FOSRR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                FOSRR { bits }
-            }
-            #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"]
-            #[inline]
-            pub fn iosr(&self) -> IOSRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IOSRR { bits }
-            }
-        }
-        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 29:31 - Sinc filter order"]
-            #[inline]
-            pub fn ford(&mut self) -> _FORDW {
-                _FORDW { w: self }
-            }
-            #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"]
-            #[inline]
-            pub fn fosr(&mut self) -> _FOSRW {
-                _FOSRW { w: self }
-            }
-            #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"]
-            #[inline]
-            pub fn iosr(&mut self) -> _IOSRW {
-                _IOSRW { w: self }
-            }
-        }
-    }
-    #[doc = "data register for injected group"]
-    pub struct FLT2JDATAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register for injected group"]
-    pub mod flt2jdatar {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT2JDATAR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATAR {
-            bits: u32,
-        }
-        impl JDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATACHR {
-            bits: u8,
-        }
-        impl JDATACHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Injected group conversion data"]
-            #[inline]
-            pub fn jdata(&self) -> JDATAR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                JDATAR { bits }
-            }
-            #[doc = "Bits 0:2 - Injected channel most recently converted"]
-            #[inline]
-            pub fn jdatach(&self) -> JDATACHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JDATACHR { bits }
-            }
-        }
-    }
-    #[doc = "data register for the regular channel"]
-    pub struct FLT2RDATAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register for the regular channel"]
-    pub mod flt2rdatar {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT2RDATAR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RDATAR {
-            bits: u32,
-        }
-        impl RDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RPENDR {
-            bits: bool,
-        }
-        impl RPENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RDATACHR {
-            bits: u8,
-        }
-        impl RDATACHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Regular channel conversion data"]
-            #[inline]
-            pub fn rdata(&self) -> RDATAR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                RDATAR { bits }
-            }
-            #[doc = "Bit 4 - Regular channel pending data"]
-            #[inline]
-            pub fn rpend(&self) -> RPENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RPENDR { bits }
-            }
-            #[doc = "Bits 0:2 - Regular channel most recently converted"]
-            #[inline]
-            pub fn rdatach(&self) -> RDATACHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RDATACHR { bits }
-            }
-        }
-    }
-    #[doc = "analog watchdog high threshold register"]
-    pub struct FLT2AWHTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog high threshold register"]
-    pub mod flt2awhtr {
-        #[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::FLT2AWHTR {
-            #[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 = r" Value of the field"]
-        pub struct AWHTR {
-            bits: u32,
-        }
-        impl AWHTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKAWHR {
-            bits: u8,
-        }
-        impl BKAWHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWHTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWHTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKAWHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKAWHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 8:31 - Analog watchdog high threshold"]
-            #[inline]
-            pub fn awht(&self) -> AWHTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AWHTR { bits }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"]
-            #[inline]
-            pub fn bkawh(&self) -> BKAWHR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKAWHR { bits }
-            }
-        }
-        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 8:31 - Analog watchdog high threshold"]
-            #[inline]
-            pub fn awht(&mut self) -> _AWHTW {
-                _AWHTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"]
-            #[inline]
-            pub fn bkawh(&mut self) -> _BKAWHW {
-                _BKAWHW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog low threshold register"]
-    pub struct FLT2AWLTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog low threshold register"]
-    pub mod flt2awltr {
-        #[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::FLT2AWLTR {
-            #[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 = r" Value of the field"]
-        pub struct AWLTR {
-            bits: u32,
-        }
-        impl AWLTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKAWLR {
-            bits: u8,
-        }
-        impl BKAWLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWLTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWLTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKAWLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKAWLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 8:31 - Analog watchdog low threshold"]
-            #[inline]
-            pub fn awlt(&self) -> AWLTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AWLTR { bits }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"]
-            #[inline]
-            pub fn bkawl(&self) -> BKAWLR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKAWLR { bits }
-            }
-        }
-        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 8:31 - Analog watchdog low threshold"]
-            #[inline]
-            pub fn awlt(&mut self) -> _AWLTW {
-                _AWLTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"]
-            #[inline]
-            pub fn bkawl(&mut self) -> _BKAWLW {
-                _BKAWLW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog status register"]
-    pub struct FLT2AWSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog status register"]
-    pub mod flt2awsr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT2AWSR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWHTFR {
-            bits: u8,
-        }
-        impl AWHTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWLTFR {
-            bits: u8,
-        }
-        impl AWLTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:15 - Analog watchdog high threshold flag"]
-            #[inline]
-            pub fn awhtf(&self) -> AWHTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWHTFR { bits }
-            }
-            #[doc = "Bits 0:7 - Analog watchdog low threshold flag"]
-            #[inline]
-            pub fn awltf(&self) -> AWLTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWLTFR { bits }
-            }
-        }
-    }
-    #[doc = "analog watchdog clear flag register"]
-    pub struct FLT2AWCFR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog clear flag register"]
-    pub mod flt2awcfr {
-        #[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::FLT2AWCFR {
-            #[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 = r" Value of the field"]
-        pub struct CLRAWHTFR {
-            bits: u8,
-        }
-        impl CLRAWHTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRAWLTFR {
-            bits: u8,
-        }
-        impl CLRAWLTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRAWHTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRAWHTFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRAWLTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRAWLTFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 8:15 - Clear the analog watchdog high threshold flag"]
-            #[inline]
-            pub fn clrawhtf(&self) -> CLRAWHTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRAWHTFR { bits }
-            }
-            #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"]
-            #[inline]
-            pub fn clrawltf(&self) -> CLRAWLTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRAWLTFR { bits }
-            }
-        }
-        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 8:15 - Clear the analog watchdog high threshold flag"]
-            #[inline]
-            pub fn clrawhtf(&mut self) -> _CLRAWHTFW {
-                _CLRAWHTFW { w: self }
-            }
-            #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"]
-            #[inline]
-            pub fn clrawltf(&mut self) -> _CLRAWLTFW {
-                _CLRAWLTFW { w: self }
-            }
-        }
-    }
-    #[doc = "Extremes detector maximum register"]
-    pub struct FLT2EXMAX {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Extremes detector maximum register"]
-    pub mod flt2exmax {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT2EXMAX {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMAXR {
-            bits: u32,
-        }
-        impl EXMAXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMAXCHR {
-            bits: u8,
-        }
-        impl EXMAXCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Extremes detector maximum value"]
-            #[inline]
-            pub fn exmax(&self) -> EXMAXR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXMAXR { bits }
-            }
-            #[doc = "Bits 0:2 - Extremes detector maximum data channel"]
-            #[inline]
-            pub fn exmaxch(&self) -> EXMAXCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXMAXCHR { bits }
-            }
-        }
-    }
-    #[doc = "Extremes detector minimum register"]
-    pub struct FLT2EXMIN {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Extremes detector minimum register"]
-    pub mod flt2exmin {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT2EXMIN {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMINR {
-            bits: u32,
-        }
-        impl EXMINR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMINCHR {
-            bits: u8,
-        }
-        impl EXMINCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - EXMIN"]
-            #[inline]
-            pub fn exmin(&self) -> EXMINR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXMINR { bits }
-            }
-            #[doc = "Bits 0:2 - Extremes detector minimum data channel"]
-            #[inline]
-            pub fn exminch(&self) -> EXMINCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXMINCHR { bits }
-            }
-        }
-    }
-    #[doc = "conversion timer register"]
-    pub struct FLT2CNVTIMR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "conversion timer register"]
-    pub mod flt2cnvtimr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT2CNVTIMR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CNVCNTR {
-            bits: u32,
-        }
-        impl CNVCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            # [ doc = "Bits 4:31 - 28-bit timer counting conversion time t = CNVCNT[27:0] / fDFSDM_CKIN" ] # [ inline ]
-            pub fn cnvcnt(&self) -> CNVCNTR {
-                let bits = {
-                    const MASK: u32 = 0x0fff_ffff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CNVCNTR { bits }
-            }
-        }
-    }
-    #[doc = "control register 1"]
-    pub struct FLT3CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod flt3cr1 {
-        #[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::FLT3CR1 {
-            #[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 = r" Value of the field"]
-        pub struct AWFSELR {
-            bits: bool,
-        }
-        impl AWFSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FASTR {
-            bits: bool,
-        }
-        impl FASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCHR {
-            bits: u8,
-        }
-        impl RCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RDMAENR {
-            bits: bool,
-        }
-        impl RDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSYNCR {
-            bits: bool,
-        }
-        impl RSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RCONTR {
-            bits: bool,
-        }
-        impl RCONTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RSWSTARTR {
-            bits: bool,
-        }
-        impl RSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEXTENR {
-            bits: u8,
-        }
-        impl JEXTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JEXTSELR {
-            bits: u8,
-        }
-        impl JEXTSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDMAENR {
-            bits: bool,
-        }
-        impl JDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSCANR {
-            bits: bool,
-        }
-        impl JSCANR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSYNCR {
-            bits: bool,
-        }
-        impl JSYNCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JSWSTARTR {
-            bits: bool,
-        }
-        impl JSWSTARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFENR {
-            bits: bool,
-        }
-        impl DFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWFSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWFSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FASTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RCONTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RCONTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEXTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JEXTSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEXTSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSCANW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSCANW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSYNCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSYNCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JSWSTARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JSWSTARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 30 - Analog watchdog fast mode select"]
-            #[inline]
-            pub fn awfsel(&self) -> AWFSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWFSELR { bits }
-            }
-            #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"]
-            #[inline]
-            pub fn fast(&self) -> FASTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FASTR { bits }
-            }
-            #[doc = "Bits 24:26 - Regular channel selection"]
-            #[inline]
-            pub fn rch(&self) -> RCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RCHR { bits }
-            }
-            #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"]
-            #[inline]
-            pub fn rdmaen(&self) -> RDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RDMAENR { bits }
-            }
-            #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"]
-            #[inline]
-            pub fn rsync(&self) -> RSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSYNCR { bits }
-            }
-            #[doc = "Bit 18 - Continuous mode selection for regular conversions"]
-            #[inline]
-            pub fn rcont(&self) -> RCONTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCONTR { bits }
-            }
-            #[doc = "Bit 17 - Software start of a conversion on the regular channel"]
-            #[inline]
-            pub fn rswstart(&self) -> RSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RSWSTARTR { bits }
-            }
-            # [ doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions" ] # [ inline ]
-            pub fn jexten(&self) -> JEXTENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTENR { bits }
-            }
-            #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"]
-            #[inline]
-            pub fn jextsel(&self) -> JEXTSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JEXTSELR { bits }
-            }
-            #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"]
-            #[inline]
-            pub fn jdmaen(&self) -> JDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JDMAENR { bits }
-            }
-            #[doc = "Bit 4 - Scanning conversion mode for injected conversions"]
-            #[inline]
-            pub fn jscan(&self) -> JSCANR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSCANR { bits }
-            }
-            # [ doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger" ] # [ inline ]
-            pub fn jsync(&self) -> JSYNCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSYNCR { bits }
-            }
-            #[doc = "Bit 1 - Start a conversion of the injected group of channels"]
-            #[inline]
-            pub fn jswstart(&self) -> JSWSTARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JSWSTARTR { bits }
-            }
-            #[doc = "Bit 0 - DFSDM enable"]
-            #[inline]
-            pub fn dfen(&self) -> DFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFENR { bits }
-            }
-        }
-        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 30 - Analog watchdog fast mode select"]
-            #[inline]
-            pub fn awfsel(&mut self) -> _AWFSELW {
-                _AWFSELW { w: self }
-            }
-            #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"]
-            #[inline]
-            pub fn fast(&mut self) -> _FASTW {
-                _FASTW { w: self }
-            }
-            #[doc = "Bits 24:26 - Regular channel selection"]
-            #[inline]
-            pub fn rch(&mut self) -> _RCHW {
-                _RCHW { w: self }
-            }
-            #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"]
-            #[inline]
-            pub fn rdmaen(&mut self) -> _RDMAENW {
-                _RDMAENW { w: self }
-            }
-            #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"]
-            #[inline]
-            pub fn rsync(&mut self) -> _RSYNCW {
-                _RSYNCW { w: self }
-            }
-            #[doc = "Bit 18 - Continuous mode selection for regular conversions"]
-            #[inline]
-            pub fn rcont(&mut self) -> _RCONTW {
-                _RCONTW { w: self }
-            }
-            #[doc = "Bit 17 - Software start of a conversion on the regular channel"]
-            #[inline]
-            pub fn rswstart(&mut self) -> _RSWSTARTW {
-                _RSWSTARTW { w: self }
-            }
-            # [ doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions" ] # [ inline ]
-            pub fn jexten(&mut self) -> _JEXTENW {
-                _JEXTENW { w: self }
-            }
-            #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"]
-            #[inline]
-            pub fn jextsel(&mut self) -> _JEXTSELW {
-                _JEXTSELW { w: self }
-            }
-            #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"]
-            #[inline]
-            pub fn jdmaen(&mut self) -> _JDMAENW {
-                _JDMAENW { w: self }
-            }
-            #[doc = "Bit 4 - Scanning conversion mode for injected conversions"]
-            #[inline]
-            pub fn jscan(&mut self) -> _JSCANW {
-                _JSCANW { w: self }
-            }
-            # [ doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger" ] # [ inline ]
-            pub fn jsync(&mut self) -> _JSYNCW {
-                _JSYNCW { w: self }
-            }
-            #[doc = "Bit 1 - Start a conversion of the injected group of channels"]
-            #[inline]
-            pub fn jswstart(&mut self) -> _JSWSTARTW {
-                _JSWSTARTW { w: self }
-            }
-            #[doc = "Bit 0 - DFSDM enable"]
-            #[inline]
-            pub fn dfen(&mut self) -> _DFENW {
-                _DFENW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct FLT3CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod flt3cr2 {
-        #[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::FLT3CR2 {
-            #[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 = r" Value of the field"]
-        pub struct AWDCHR {
-            bits: u8,
-        }
-        impl AWDCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXCHR {
-            bits: u8,
-        }
-        impl EXCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKABIER {
-            bits: bool,
-        }
-        impl CKABIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SCDIER {
-            bits: bool,
-        }
-        impl SCDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDIER {
-            bits: bool,
-        }
-        impl AWDIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ROVRIER {
-            bits: bool,
-        }
-        impl ROVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JOVRIER {
-            bits: bool,
-        }
-        impl JOVRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REOCIER {
-            bits: bool,
-        }
-        impl REOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCIER {
-            bits: bool,
-        }
-        impl JEOCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _AWDCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKABIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKABIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SCDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWDIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWDIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ROVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ROVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JOVRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JOVRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _REOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _REOCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _JEOCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JEOCIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:23 - Analog watchdog channel selection"]
-            #[inline]
-            pub fn awdch(&self) -> AWDCHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWDCHR { bits }
-            }
-            #[doc = "Bits 8:15 - Extremes detector channel selection"]
-            #[inline]
-            pub fn exch(&self) -> EXCHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXCHR { bits }
-            }
-            #[doc = "Bit 6 - Clock absence interrupt enable"]
-            #[inline]
-            pub fn ckabie(&self) -> CKABIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKABIER { bits }
-            }
-            #[doc = "Bit 5 - Short-circuit detector interrupt enable"]
-            #[inline]
-            pub fn scdie(&self) -> SCDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SCDIER { bits }
-            }
-            #[doc = "Bit 4 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&self) -> AWDIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDIER { bits }
-            }
-            #[doc = "Bit 3 - Regular data overrun interrupt enable"]
-            #[inline]
-            pub fn rovrie(&self) -> ROVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ROVRIER { bits }
-            }
-            #[doc = "Bit 2 - Injected data overrun interrupt enable"]
-            #[inline]
-            pub fn jovrie(&self) -> JOVRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JOVRIER { bits }
-            }
-            #[doc = "Bit 1 - Regular end of conversion interrupt enable"]
-            #[inline]
-            pub fn reocie(&self) -> REOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REOCIER { bits }
-            }
-            #[doc = "Bit 0 - Injected end of conversion interrupt enable"]
-            #[inline]
-            pub fn jeocie(&self) -> JEOCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCIER { bits }
-            }
-        }
-        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 16:23 - Analog watchdog channel selection"]
-            #[inline]
-            pub fn awdch(&mut self) -> _AWDCHW {
-                _AWDCHW { w: self }
-            }
-            #[doc = "Bits 8:15 - Extremes detector channel selection"]
-            #[inline]
-            pub fn exch(&mut self) -> _EXCHW {
-                _EXCHW { w: self }
-            }
-            #[doc = "Bit 6 - Clock absence interrupt enable"]
-            #[inline]
-            pub fn ckabie(&mut self) -> _CKABIEW {
-                _CKABIEW { w: self }
-            }
-            #[doc = "Bit 5 - Short-circuit detector interrupt enable"]
-            #[inline]
-            pub fn scdie(&mut self) -> _SCDIEW {
-                _SCDIEW { w: self }
-            }
-            #[doc = "Bit 4 - Analog watchdog interrupt enable"]
-            #[inline]
-            pub fn awdie(&mut self) -> _AWDIEW {
-                _AWDIEW { w: self }
-            }
-            #[doc = "Bit 3 - Regular data overrun interrupt enable"]
-            #[inline]
-            pub fn rovrie(&mut self) -> _ROVRIEW {
-                _ROVRIEW { w: self }
-            }
-            #[doc = "Bit 2 - Injected data overrun interrupt enable"]
-            #[inline]
-            pub fn jovrie(&mut self) -> _JOVRIEW {
-                _JOVRIEW { w: self }
-            }
-            #[doc = "Bit 1 - Regular end of conversion interrupt enable"]
-            #[inline]
-            pub fn reocie(&mut self) -> _REOCIEW {
-                _REOCIEW { w: self }
-            }
-            #[doc = "Bit 0 - Injected end of conversion interrupt enable"]
-            #[inline]
-            pub fn jeocie(&mut self) -> _JEOCIEW {
-                _JEOCIEW { w: self }
-            }
-        }
-    }
-    #[doc = "interrupt and status register"]
-    pub struct FLT3ISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt and status register"]
-    pub mod flt3isr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT3ISR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCDFR {
-            bits: u8,
-        }
-        impl SCDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKABFR {
-            bits: u8,
-        }
-        impl CKABFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RCIPR {
-            bits: bool,
-        }
-        impl RCIPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JCIPR {
-            bits: bool,
-        }
-        impl JCIPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWDFR {
-            bits: bool,
-        }
-        impl AWDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ROVRFR {
-            bits: bool,
-        }
-        impl ROVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JOVRFR {
-            bits: bool,
-        }
-        impl JOVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct REOCFR {
-            bits: bool,
-        }
-        impl REOCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct JEOCFR {
-            bits: bool,
-        }
-        impl JEOCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - short-circuit detector flag"]
-            #[inline]
-            pub fn scdf(&self) -> SCDFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCDFR { bits }
-            }
-            #[doc = "Bits 16:23 - Clock absence flag"]
-            #[inline]
-            pub fn ckabf(&self) -> CKABFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKABFR { bits }
-            }
-            #[doc = "Bit 14 - Regular conversion in progress status"]
-            #[inline]
-            pub fn rcip(&self) -> RCIPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RCIPR { bits }
-            }
-            #[doc = "Bit 13 - Injected conversion in progress status"]
-            #[inline]
-            pub fn jcip(&self) -> JCIPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JCIPR { bits }
-            }
-            #[doc = "Bit 4 - Analog watchdog"]
-            #[inline]
-            pub fn awdf(&self) -> AWDFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWDFR { bits }
-            }
-            #[doc = "Bit 3 - Regular conversion overrun flag"]
-            #[inline]
-            pub fn rovrf(&self) -> ROVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ROVRFR { bits }
-            }
-            #[doc = "Bit 2 - Injected conversion overrun flag"]
-            #[inline]
-            pub fn jovrf(&self) -> JOVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JOVRFR { bits }
-            }
-            #[doc = "Bit 1 - End of regular conversion flag"]
-            #[inline]
-            pub fn reocf(&self) -> REOCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                REOCFR { bits }
-            }
-            #[doc = "Bit 0 - End of injected conversion flag"]
-            #[inline]
-            pub fn jeocf(&self) -> JEOCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                JEOCFR { bits }
-            }
-        }
-    }
-    #[doc = "interrupt flag clear register"]
-    pub struct FLT3ICR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt flag clear register"]
-    pub mod flt3icr {
-        #[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::FLT3ICR {
-            #[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 = r" Value of the field"]
-        pub struct CLRSCDFR {
-            bits: u8,
-        }
-        impl CLRSCDFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRCKABFR {
-            bits: u8,
-        }
-        impl CLRCKABFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRROVRFR {
-            bits: bool,
-        }
-        impl CLRROVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CLRJOVRFR {
-            bits: bool,
-        }
-        impl CLRJOVRFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CLRSCDFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRSCDFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRCKABFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRCKABFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRROVRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRROVRFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CLRJOVRFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRJOVRFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - Clear the short-circuit detector flag"]
-            #[inline]
-            pub fn clrscdf(&self) -> CLRSCDFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRSCDFR { bits }
-            }
-            #[doc = "Bits 16:23 - Clear the clock absence flag"]
-            #[inline]
-            pub fn clrckabf(&self) -> CLRCKABFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRCKABFR { bits }
-            }
-            #[doc = "Bit 3 - Clear the regular conversion overrun flag"]
-            #[inline]
-            pub fn clrrovrf(&self) -> CLRROVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLRROVRFR { bits }
-            }
-            #[doc = "Bit 2 - Clear the injected conversion overrun flag"]
-            #[inline]
-            pub fn clrjovrf(&self) -> CLRJOVRFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CLRJOVRFR { bits }
-            }
-        }
-        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 24:31 - Clear the short-circuit detector flag"]
-            #[inline]
-            pub fn clrscdf(&mut self) -> _CLRSCDFW {
-                _CLRSCDFW { w: self }
-            }
-            #[doc = "Bits 16:23 - Clear the clock absence flag"]
-            #[inline]
-            pub fn clrckabf(&mut self) -> _CLRCKABFW {
-                _CLRCKABFW { w: self }
-            }
-            #[doc = "Bit 3 - Clear the regular conversion overrun flag"]
-            #[inline]
-            pub fn clrrovrf(&mut self) -> _CLRROVRFW {
-                _CLRROVRFW { w: self }
-            }
-            #[doc = "Bit 2 - Clear the injected conversion overrun flag"]
-            #[inline]
-            pub fn clrjovrf(&mut self) -> _CLRJOVRFW {
-                _CLRJOVRFW { w: self }
-            }
-        }
-    }
-    #[doc = "injected channel group selection register"]
-    pub struct FLT3JCHGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "injected channel group selection register"]
-    pub mod flt3jchgr {
-        #[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::FLT3JCHGR {
-            #[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 = r" Value of the field"]
-        pub struct JCHGR {
-            bits: u8,
-        }
-        impl JCHGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _JCHGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _JCHGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - Injected channel group selection"]
-            #[inline]
-            pub fn jchg(&self) -> JCHGR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JCHGR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x01 }
-            }
-            #[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 0:7 - Injected channel group selection"]
-            #[inline]
-            pub fn jchg(&mut self) -> _JCHGW {
-                _JCHGW { w: self }
-            }
-        }
-    }
-    #[doc = "filter control register"]
-    pub struct FLT3FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter control register"]
-    pub mod flt3fcr {
-        #[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::FLT3FCR {
-            #[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 = r" Value of the field"]
-        pub struct FORDR {
-            bits: u8,
-        }
-        impl FORDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FOSRR {
-            bits: u16,
-        }
-        impl FOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IOSRR {
-            bits: u8,
-        }
-        impl IOSRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FORDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FORDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IOSRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IOSRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 29:31 - Sinc filter order"]
-            #[inline]
-            pub fn ford(&self) -> FORDR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FORDR { bits }
-            }
-            #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"]
-            #[inline]
-            pub fn fosr(&self) -> FOSRR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                FOSRR { bits }
-            }
-            #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"]
-            #[inline]
-            pub fn iosr(&self) -> IOSRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IOSRR { bits }
-            }
-        }
-        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 29:31 - Sinc filter order"]
-            #[inline]
-            pub fn ford(&mut self) -> _FORDW {
-                _FORDW { w: self }
-            }
-            #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"]
-            #[inline]
-            pub fn fosr(&mut self) -> _FOSRW {
-                _FOSRW { w: self }
-            }
-            #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"]
-            #[inline]
-            pub fn iosr(&mut self) -> _IOSRW {
-                _IOSRW { w: self }
-            }
-        }
-    }
-    #[doc = "data register for injected group"]
-    pub struct FLT3JDATAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register for injected group"]
-    pub mod flt3jdatar {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT3JDATAR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATAR {
-            bits: u32,
-        }
-        impl JDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct JDATACHR {
-            bits: u8,
-        }
-        impl JDATACHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Injected group conversion data"]
-            #[inline]
-            pub fn jdata(&self) -> JDATAR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                JDATAR { bits }
-            }
-            #[doc = "Bits 0:2 - Injected channel most recently converted"]
-            #[inline]
-            pub fn jdatach(&self) -> JDATACHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                JDATACHR { bits }
-            }
-        }
-    }
-    #[doc = "data register for the regular channel"]
-    pub struct FLT3RDATAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register for the regular channel"]
-    pub mod flt3rdatar {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT3RDATAR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RDATAR {
-            bits: u32,
-        }
-        impl RDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RPENDR {
-            bits: bool,
-        }
-        impl RPENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RDATACHR {
-            bits: u8,
-        }
-        impl RDATACHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Regular channel conversion data"]
-            #[inline]
-            pub fn rdata(&self) -> RDATAR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                RDATAR { bits }
-            }
-            #[doc = "Bit 4 - Regular channel pending data"]
-            #[inline]
-            pub fn rpend(&self) -> RPENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RPENDR { bits }
-            }
-            #[doc = "Bits 0:2 - Regular channel most recently converted"]
-            #[inline]
-            pub fn rdatach(&self) -> RDATACHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RDATACHR { bits }
-            }
-        }
-    }
-    #[doc = "analog watchdog high threshold register"]
-    pub struct FLT3AWHTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog high threshold register"]
-    pub mod flt3awhtr {
-        #[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::FLT3AWHTR {
-            #[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 = r" Value of the field"]
-        pub struct AWHTR {
-            bits: u32,
-        }
-        impl AWHTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKAWHR {
-            bits: u8,
-        }
-        impl BKAWHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWHTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWHTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKAWHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKAWHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 8:31 - Analog watchdog high threshold"]
-            #[inline]
-            pub fn awht(&self) -> AWHTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AWHTR { bits }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"]
-            #[inline]
-            pub fn bkawh(&self) -> BKAWHR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKAWHR { bits }
-            }
-        }
-        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 8:31 - Analog watchdog high threshold"]
-            #[inline]
-            pub fn awht(&mut self) -> _AWHTW {
-                _AWHTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"]
-            #[inline]
-            pub fn bkawh(&mut self) -> _BKAWHW {
-                _BKAWHW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog low threshold register"]
-    pub struct FLT3AWLTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog low threshold register"]
-    pub mod flt3awltr {
-        #[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::FLT3AWLTR {
-            #[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 = r" Value of the field"]
-        pub struct AWLTR {
-            bits: u32,
-        }
-        impl AWLTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BKAWLR {
-            bits: u8,
-        }
-        impl BKAWLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AWLTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWLTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x00ff_ffff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BKAWLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BKAWLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 8:31 - Analog watchdog low threshold"]
-            #[inline]
-            pub fn awlt(&self) -> AWLTR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AWLTR { bits }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"]
-            #[inline]
-            pub fn bkawl(&self) -> BKAWLR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BKAWLR { bits }
-            }
-        }
-        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 8:31 - Analog watchdog low threshold"]
-            #[inline]
-            pub fn awlt(&mut self) -> _AWLTW {
-                _AWLTW { w: self }
-            }
-            #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"]
-            #[inline]
-            pub fn bkawl(&mut self) -> _BKAWLW {
-                _BKAWLW { w: self }
-            }
-        }
-    }
-    #[doc = "analog watchdog status register"]
-    pub struct FLT3AWSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog status register"]
-    pub mod flt3awsr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT3AWSR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWHTFR {
-            bits: u8,
-        }
-        impl AWHTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AWLTFR {
-            bits: u8,
-        }
-        impl AWLTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:15 - Analog watchdog high threshold flag"]
-            #[inline]
-            pub fn awhtf(&self) -> AWHTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWHTFR { bits }
-            }
-            #[doc = "Bits 0:7 - Analog watchdog low threshold flag"]
-            #[inline]
-            pub fn awltf(&self) -> AWLTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                AWLTFR { bits }
-            }
-        }
-    }
-    #[doc = "analog watchdog clear flag register"]
-    pub struct FLT3AWCFR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "analog watchdog clear flag register"]
-    pub mod flt3awcfr {
-        #[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::FLT3AWCFR {
-            #[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 = r" Value of the field"]
-        pub struct CLRAWHTFR {
-            bits: u8,
-        }
-        impl CLRAWHTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLRAWLTFR {
-            bits: u8,
-        }
-        impl CLRAWLTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRAWHTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRAWHTFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLRAWLTFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLRAWLTFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 8:15 - Clear the analog watchdog high threshold flag"]
-            #[inline]
-            pub fn clrawhtf(&self) -> CLRAWHTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRAWHTFR { bits }
-            }
-            #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"]
-            #[inline]
-            pub fn clrawltf(&self) -> CLRAWLTFR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLRAWLTFR { bits }
-            }
-        }
-        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 8:15 - Clear the analog watchdog high threshold flag"]
-            #[inline]
-            pub fn clrawhtf(&mut self) -> _CLRAWHTFW {
-                _CLRAWHTFW { w: self }
-            }
-            #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"]
-            #[inline]
-            pub fn clrawltf(&mut self) -> _CLRAWLTFW {
-                _CLRAWLTFW { w: self }
-            }
-        }
-    }
-    #[doc = "Extremes detector maximum register"]
-    pub struct FLT3EXMAX {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Extremes detector maximum register"]
-    pub mod flt3exmax {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT3EXMAX {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMAXR {
-            bits: u32,
-        }
-        impl EXMAXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMAXCHR {
-            bits: u8,
-        }
-        impl EXMAXCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - Extremes detector maximum value"]
-            #[inline]
-            pub fn exmax(&self) -> EXMAXR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXMAXR { bits }
-            }
-            #[doc = "Bits 0:2 - Extremes detector maximum data channel"]
-            #[inline]
-            pub fn exmaxch(&self) -> EXMAXCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXMAXCHR { bits }
-            }
-        }
-    }
-    #[doc = "Extremes detector minimum register"]
-    pub struct FLT3EXMIN {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Extremes detector minimum register"]
-    pub mod flt3exmin {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT3EXMIN {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMINR {
-            bits: u32,
-        }
-        impl EXMINR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXMINCHR {
-            bits: u8,
-        }
-        impl EXMINCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:31 - EXMIN"]
-            #[inline]
-            pub fn exmin(&self) -> EXMINR {
-                let bits = {
-                    const MASK: u32 = 0x00ff_ffff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXMINR { bits }
-            }
-            #[doc = "Bits 0:2 - Extremes detector minimum data channel"]
-            #[inline]
-            pub fn exminch(&self) -> EXMINCHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EXMINCHR { bits }
-            }
-        }
-    }
-    #[doc = "conversion timer register"]
-    pub struct FLT3CNVTIMR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "conversion timer register"]
-    pub mod flt3cnvtimr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FLT3CNVTIMR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CNVCNTR {
-            bits: u32,
-        }
-        impl CNVCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            # [ doc = "Bits 4:31 - 28-bit timer counting conversion time t = CNVCNT[27:0] / fDFSDM_CKIN" ] # [ inline ]
-            pub fn cnvcnt(&self) -> CNVCNTR {
-                let bits = {
-                    const MASK: u32 = 0x0fff_ffff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                CNVCNTR { bits }
-            }
-        }
-    }
-}
-#[doc = "DFSDM2"]
-pub struct DFSDM2 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for DFSDM2 {}
-impl DFSDM2 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const dfsdm1::RegisterBlock {
-        0x4001_6400 as *const _
-    }
-}
-impl Deref for DFSDM2 {
-    type Target = dfsdm1::RegisterBlock;
-    fn deref(&self) -> &dfsdm1::RegisterBlock {
-        unsafe { &*DFSDM2::ptr() }
-    }
-}
-#[doc = "Basic timers"]
-pub struct TIM6 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM6 {}
-impl TIM6 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim6::RegisterBlock {
-        0x4000_1000 as *const _
-    }
-}
-impl Deref for TIM6 {
-    type Target = tim6::RegisterBlock;
-    fn deref(&self) -> &tim6::RegisterBlock {
-        unsafe { &*TIM6::ptr() }
-    }
-}
-#[doc = "Basic timers"]
-pub mod tim6 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - control register 2"]
-        pub cr2: CR2,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        _reserved1: [u8; 12usize],
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPMR {
-            bits: bool,
-        }
-        impl OPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFREMAPR {
-            bits: bool,
-        }
-        impl UIFREMAPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFREMAPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFREMAPW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&self) -> OPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPMR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bit 11 - UIF status bit remapping"]
-            #[inline]
-            pub fn uifremap(&self) -> UIFREMAPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFREMAPR { bits }
-            }
-        }
-        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 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&mut self) -> _OPMW {
-                _OPMW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bit 11 - UIF status bit remapping"]
-            #[inline]
-            pub fn uifremap(&mut self) -> _UIFREMAPW {
-                _UIFREMAPW { w: self }
-            }
-        }
-    }
-    #[doc = "control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct MMSR {
-            bits: u8,
-        }
-        impl MMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                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 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&self) -> MMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MMSR { bits }
-            }
-        }
-        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 4:6 - Master mode selection"]
-            #[inline]
-            pub fn mms(&mut self) -> _MMSW {
-                _MMSW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct UDER {
-            bits: bool,
-        }
-        impl UDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _UDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&self) -> UDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 8 - Update DMA request enable"]
-            #[inline]
-            pub fn ude(&mut self) -> _UDEW {
-                _UDEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNTR {
-            bits: u16,
-        }
-        impl CNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct UIFCPYR {
-            bits: bool,
-        }
-        impl UIFCPYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Low counter value"]
-            #[inline]
-            pub fn cnt(&self) -> CNTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNTR { bits }
-            }
-            #[doc = "Bit 31 - UIF Copy"]
-            #[inline]
-            pub fn uifcpy(&self) -> UIFCPYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFCPYR { bits }
-            }
-        }
-        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 0:15 - Low counter value"]
-            #[inline]
-            pub fn cnt(&mut self) -> _CNTW {
-                _CNTW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARRR {
-            bits: u16,
-        }
-        impl ARRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Low Auto-reload value"]
-            #[inline]
-            pub fn arr(&self) -> ARRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARRR { bits }
-            }
-        }
-        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 0:15 - Low Auto-reload value"]
-            #[inline]
-            pub fn arr(&mut self) -> _ARRW {
-                _ARRW { w: self }
-            }
-        }
-    }
-}
-#[doc = "TIM7"]
-pub struct TIM7 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM7 {}
-impl TIM7 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim6::RegisterBlock {
-        0x4000_1400 as *const _
-    }
-}
-impl Deref for TIM7 {
-    type Target = tim6::RegisterBlock;
-    fn deref(&self) -> &tim6::RegisterBlock {
-        unsafe { &*TIM7::ptr() }
-    }
-}
-#[doc = "General purpose timers"]
-pub struct TIM12 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM12 {}
-impl TIM12 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim12::RegisterBlock {
-        0x4000_1800 as *const _
-    }
-}
-impl Deref for TIM12 {
-    type Target = tim12::RegisterBlock;
-    fn deref(&self) -> &tim12::RegisterBlock {
-        unsafe { &*TIM12::ptr() }
-    }
-}
-#[doc = "General purpose timers"]
-pub mod tim12 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x08 - slave mode control register"]
-        pub smcr: SMCR,
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        _reserved2: [u8; 4usize],
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-        #[doc = "0x38 - capture/compare register 2"]
-        pub ccr2: CCR2,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OPMR {
-            bits: bool,
-        }
-        impl OPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&self) -> OPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OPMR { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bit 3 - One-pulse mode"]
-            #[inline]
-            pub fn opm(&mut self) -> _OPMW {
-                _OPMW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "slave mode control register"]
-    pub struct SMCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "slave mode control register"]
-    pub mod smcr {
-        #[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::SMCR {
-            #[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 = r" Value of the field"]
-        pub struct MSMR {
-            bits: bool,
-        }
-        impl MSMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TSR {
-            bits: u8,
-        }
-        impl TSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SMSR {
-            bits: u8,
-        }
-        impl SMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MSMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MSMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 = "Bit 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&self) -> MSMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MSMR { bits }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&self) -> TSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TSR { bits }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&self) -> SMSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SMSR { bits }
-            }
-        }
-        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 7 - Master/Slave mode"]
-            #[inline]
-            pub fn msm(&mut self) -> _MSMW {
-                _MSMW { w: self }
-            }
-            #[doc = "Bits 4:6 - Trigger selection"]
-            #[inline]
-            pub fn ts(&mut self) -> _TSW {
-                _TSW { w: self }
-            }
-            #[doc = "Bits 0:2 - Slave mode selection"]
-            #[inline]
-            pub fn sms(&mut self) -> _SMSW {
-                _SMSW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct TIER {
-            bits: bool,
-        }
-        impl TIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IER {
-            bits: bool,
-        }
-        impl CC2IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&self) -> TIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIER { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&self) -> CC2IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IER { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 6 - Trigger interrupt enable"]
-            #[inline]
-            pub fn tie(&mut self) -> _TIEW {
-                _TIEW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"]
-            #[inline]
-            pub fn cc2ie(&mut self) -> _CC2IEW {
-                _CC2IEW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC2OFR {
-            bits: bool,
-        }
-        impl CC2OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIFR {
-            bits: bool,
-        }
-        impl TIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2IFR {
-            bits: bool,
-        }
-        impl CC2IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC2OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&self) -> CC2OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2OFR { bits }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&self) -> TIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIFR { bits }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&self) -> CC2IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2IFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 10 - Capture/compare 2 overcapture flag"]
-            #[inline]
-            pub fn cc2of(&mut self) -> _CC2OFW {
-                _CC2OFW { w: self }
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 6 - Trigger interrupt flag"]
-            #[inline]
-            pub fn tif(&mut self) -> _TIFW {
-                _TIFW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
-            #[inline]
-            pub fn cc2if(&mut self) -> _CC2IFW {
-                _CC2IFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _TGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 6 - Trigger generation"]
-            #[inline]
-            pub fn tg(&mut self) -> _TGW {
-                _TGW { w: self }
-            }
-            #[doc = "Bit 2 - Capture/compare 2 generation"]
-            #[inline]
-            pub fn cc2g(&mut self) -> _CC2GW {
-                _CC2GW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct OC2MR {
-            bits: u8,
-        }
-        impl OC2MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC2PER {
-            bits: bool,
-        }
-        impl OC2PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC2FER {
-            bits: bool,
-        }
-        impl OC2FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC2PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC2FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC2FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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:14 - Output Compare 2 mode"]
-            #[inline]
-            pub fn oc2m(&self) -> OC2MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC2MR { bits }
-            }
-            #[doc = "Bit 11 - Output Compare 2 preload enable"]
-            #[inline]
-            pub fn oc2pe(&self) -> OC2PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2PER { bits }
-            }
-            #[doc = "Bit 10 - Output Compare 2 fast enable"]
-            #[inline]
-            pub fn oc2fe(&self) -> OC2FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC2FER { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bits 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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:14 - Output Compare 2 mode"]
-            #[inline]
-            pub fn oc2m(&mut self) -> _OC2MW {
-                _OC2MW { w: self }
-            }
-            #[doc = "Bit 11 - Output Compare 2 preload enable"]
-            #[inline]
-            pub fn oc2pe(&mut self) -> _OC2PEW {
-                _OC2PEW { w: self }
-            }
-            #[doc = "Bit 10 - Output Compare 2 fast enable"]
-            #[inline]
-            pub fn oc2fe(&mut self) -> _OC2FEW {
-                _OC2FEW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bits 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bit 2 - Output Compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register 1 (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC2FR {
-            bits: u8,
-        }
-        impl IC2FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC2PSCR {
-            bits: u8,
-        }
-        impl IC2PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC2SR {
-            bits: u8,
-        }
-        impl CC2SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC1PSCR {
-            bits: u8,
-        }
-        impl IC1PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC2PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC2PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC2SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&self) -> IC2FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2FR { bits }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2psc(&self) -> IC2PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC2PSCR { bits }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&self) -> CC2SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC2SR { bits }
-            }
-            #[doc = "Bits 4:6 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn ic1psc(&self) -> IC1PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1PSCR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 - Input capture 2 filter"]
-            #[inline]
-            pub fn ic2f(&mut self) -> _IC2FW {
-                _IC2FW { w: self }
-            }
-            #[doc = "Bits 10:11 - Input capture 2 prescaler"]
-            #[inline]
-            pub fn ic2psc(&mut self) -> _IC2PSCW {
-                _IC2PSCW { w: self }
-            }
-            #[doc = "Bits 8:9 - Capture/Compare 2 selection"]
-            #[inline]
-            pub fn cc2s(&mut self) -> _CC2SW {
-                _CC2SW { w: self }
-            }
-            #[doc = "Bits 4:6 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn ic1psc(&mut self) -> _IC1PSCW {
-                _IC1PSCW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC2NPR {
-            bits: bool,
-        }
-        impl CC2NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2PR {
-            bits: bool,
-        }
-        impl CC2PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC2ER {
-            bits: bool,
-        }
-        impl CC2ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC2NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC2EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC2EW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&self) -> CC2NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2NPR { bits }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&self) -> CC2PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2PR { bits }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&self) -> CC2ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC2ER { bits }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 7 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2np(&mut self) -> _CC2NPW {
-                _CC2NPW { w: self }
-            }
-            #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
-            #[inline]
-            pub fn cc2p(&mut self) -> _CC2PW {
-                _CC2PW { w: self }
-            }
-            #[doc = "Bit 4 - Capture/Compare 2 output enable"]
-            #[inline]
-            pub fn cc2e(&mut self) -> _CC2EW {
-                _CC2EW { w: self }
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNTR {
-            bits: u16,
-        }
-        impl CNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&self) -> CNTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNTR { bits }
-            }
-        }
-        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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&mut self) -> _CNTW {
-                _CNTW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARRR {
-            bits: u16,
-        }
-        impl ARRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&self) -> ARRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARRR { bits }
-            }
-        }
-        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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&mut self) -> _ARRW {
-                _ARRW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1R {
-            bits: u16,
-        }
-        impl CCR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&self) -> CCR1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&mut self) -> _CCR1W {
-                _CCR1W { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 2"]
-    pub struct CCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 2"]
-    pub mod ccr2 {
-        #[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::CCR2 {
-            #[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 = r" Value of the field"]
-        pub struct CCR2R {
-            bits: u16,
-        }
-        impl CCR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2(&self) -> CCR2R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR2R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 2 value"]
-            #[inline]
-            pub fn ccr2(&mut self) -> _CCR2W {
-                _CCR2W { w: self }
-            }
-        }
-    }
-}
-#[doc = "General purpose timers"]
-pub struct TIM13 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM13 {}
-impl TIM13 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim13::RegisterBlock {
-        0x4000_1c00 as *const _
-    }
-}
-impl Deref for TIM13 {
-    type Target = tim13::RegisterBlock;
-    fn deref(&self) -> &tim13::RegisterBlock {
-        unsafe { &*TIM13::ptr() }
-    }
-}
-#[doc = "General purpose timers"]
-pub mod tim13 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register 1"]
-        pub cr1: CR1,
-        _reserved0: [u8; 8usize],
-        #[doc = "0x0c - DMA/Interrupt enable register"]
-        pub dier: DIER,
-        #[doc = "0x10 - status register"]
-        pub sr: SR,
-        #[doc = "0x14 - event generation register"]
-        pub egr: EGR,
-        #[doc = "0x18 - capture/compare mode register (output mode)"]
-        pub ccmr1_output: CCMR1_OUTPUT,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x20 - capture/compare enable register"]
-        pub ccer: CCER,
-        #[doc = "0x24 - counter"]
-        pub cnt: CNT,
-        #[doc = "0x28 - prescaler"]
-        pub psc: PSC,
-        #[doc = "0x2c - auto-reload register"]
-        pub arr: ARR,
-        _reserved2: [u8; 4usize],
-        #[doc = "0x34 - capture/compare register 1"]
-        pub ccr1: CCR1,
-    }
-    #[doc = "control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct CKDR {
-            bits: u8,
-        }
-        impl CKDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ARPER {
-            bits: bool,
-        }
-        impl ARPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct URSR {
-            bits: bool,
-        }
-        impl URSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UDISR {
-            bits: bool,
-        }
-        impl UDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CENR {
-            bits: bool,
-        }
-        impl CENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CKDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARPEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _URSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _URSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&self) -> CKDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKDR { bits }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&self) -> ARPER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARPER { bits }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&self) -> URSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                URSR { bits }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&self) -> UDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UDISR { bits }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&self) -> CENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CENR { bits }
-            }
-        }
-        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 8:9 - Clock division"]
-            #[inline]
-            pub fn ckd(&mut self) -> _CKDW {
-                _CKDW { w: self }
-            }
-            #[doc = "Bit 7 - Auto-reload preload enable"]
-            #[inline]
-            pub fn arpe(&mut self) -> _ARPEW {
-                _ARPEW { w: self }
-            }
-            #[doc = "Bit 2 - Update request source"]
-            #[inline]
-            pub fn urs(&mut self) -> _URSW {
-                _URSW { w: self }
-            }
-            #[doc = "Bit 1 - Update disable"]
-            #[inline]
-            pub fn udis(&mut self) -> _UDISW {
-                _UDISW { w: self }
-            }
-            #[doc = "Bit 0 - Counter enable"]
-            #[inline]
-            pub fn cen(&mut self) -> _CENW {
-                _CENW { w: self }
-            }
-        }
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub struct DIER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DMA/Interrupt enable register"]
-    pub mod dier {
-        #[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::DIER {
-            #[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 = r" Value of the field"]
-        pub struct CC1IER {
-            bits: bool,
-        }
-        impl CC1IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIER {
-            bits: bool,
-        }
-        impl UIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&self) -> CC1IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IER { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&self) -> UIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIER { bits }
-            }
-        }
-        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 1 - Capture/Compare 1 interrupt enable"]
-            #[inline]
-            pub fn cc1ie(&mut self) -> _CC1IEW {
-                _CC1IEW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt enable"]
-            #[inline]
-            pub fn uie(&mut self) -> _UIEW {
-                _UIEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct CC1OFR {
-            bits: bool,
-        }
-        impl CC1OFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1IFR {
-            bits: bool,
-        }
-        impl CC1IFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UIFR {
-            bits: bool,
-        }
-        impl UIFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1OFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1OFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1IFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1IFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UIFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UIFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&self) -> CC1OFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1OFR { bits }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&self) -> CC1IFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1IFR { bits }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&self) -> UIFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UIFR { bits }
-            }
-        }
-        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 9 - Capture/Compare 1 overcapture flag"]
-            #[inline]
-            pub fn cc1of(&mut self) -> _CC1OFW {
-                _CC1OFW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
-            #[inline]
-            pub fn cc1if(&mut self) -> _CC1IFW {
-                _CC1IFW { w: self }
-            }
-            #[doc = "Bit 0 - Update interrupt flag"]
-            #[inline]
-            pub fn uif(&mut self) -> _UIFW {
-                _UIFW { w: self }
-            }
-        }
-    }
-    #[doc = "event generation register"]
-    pub struct EGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "event generation register"]
-    pub mod egr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::EGR {
-            #[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" Proxy"]
-        pub struct _CC1GW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1GW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UGW<'a> {
-            #[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
-            }
-        }
-        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 1 - Capture/compare 1 generation"]
-            #[inline]
-            pub fn cc1g(&mut self) -> _CC1GW {
-                _CC1GW { w: self }
-            }
-            #[doc = "Bit 0 - Update generation"]
-            #[inline]
-            pub fn ug(&mut self) -> _UGW {
-                _UGW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register (output mode)"]
-    pub struct CCMR1_OUTPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register (output mode)"]
-    pub mod ccmr1_output {
-        #[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::CCMR1_OUTPUT {
-            #[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 = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OC1FER {
-            bits: bool,
-        }
-        impl OC1FER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1PER {
-            bits: bool,
-        }
-        impl OC1PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OC1MR {
-            bits: u8,
-        }
-        impl OC1MR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OC1FEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1FEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OC1MW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OC1MW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                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 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-            #[doc = "Bit 2 - Output compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&self) -> OC1FER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1FER { bits }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&self) -> OC1PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OC1PER { bits }
-            }
-            #[doc = "Bits 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&self) -> OC1MR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OC1MR { bits }
-            }
-        }
-        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 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-            #[doc = "Bit 2 - Output compare 1 fast enable"]
-            #[inline]
-            pub fn oc1fe(&mut self) -> _OC1FEW {
-                _OC1FEW { w: self }
-            }
-            #[doc = "Bit 3 - Output Compare 1 preload enable"]
-            #[inline]
-            pub fn oc1pe(&mut self) -> _OC1PEW {
-                _OC1PEW { w: self }
-            }
-            #[doc = "Bits 4:6 - Output Compare 1 mode"]
-            #[inline]
-            pub fn oc1m(&mut self) -> _OC1MW {
-                _OC1MW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare mode register (input mode)"]
-    pub struct CCMR1_INPUT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare mode register (input mode)"]
-    pub mod ccmr1_input {
-        #[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::CCMR1_INPUT {
-            #[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 = r" Value of the field"]
-        pub struct IC1FR {
-            bits: u8,
-        }
-        impl IC1FR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IC1PSCR {
-            bits: u8,
-        }
-        impl IC1PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CC1SR {
-            bits: u8,
-        }
-        impl CC1SR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1FW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1FW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IC1PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IC1PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CC1SW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1SW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&self) -> IC1FR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1FR { bits }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn ic1psc(&self) -> IC1PSCR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IC1PSCR { bits }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&self) -> CC1SR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CC1SR { bits }
-            }
-        }
-        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 4:7 - Input capture 1 filter"]
-            #[inline]
-            pub fn ic1f(&mut self) -> _IC1FW {
-                _IC1FW { w: self }
-            }
-            #[doc = "Bits 2:3 - Input capture 1 prescaler"]
-            #[inline]
-            pub fn ic1psc(&mut self) -> _IC1PSCW {
-                _IC1PSCW { w: self }
-            }
-            #[doc = "Bits 0:1 - Capture/Compare 1 selection"]
-            #[inline]
-            pub fn cc1s(&mut self) -> _CC1SW {
-                _CC1SW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare enable register"]
-    pub struct CCER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare enable register"]
-    pub mod ccer {
-        #[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::CCER {
-            #[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 = r" Value of the field"]
-        pub struct CC1NPR {
-            bits: bool,
-        }
-        impl CC1NPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1PR {
-            bits: bool,
-        }
-        impl CC1PR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CC1ER {
-            bits: bool,
-        }
-        impl CC1ER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CC1NPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1NPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1PW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1PW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CC1EW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CC1EW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&self) -> CC1NPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1NPR { bits }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&self) -> CC1PR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1PR { bits }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&self) -> CC1ER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CC1ER { bits }
-            }
-        }
-        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 3 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1np(&mut self) -> _CC1NPW {
-                _CC1NPW { w: self }
-            }
-            #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
-            #[inline]
-            pub fn cc1p(&mut self) -> _CC1PW {
-                _CC1PW { w: self }
-            }
-            #[doc = "Bit 0 - Capture/Compare 1 output enable"]
-            #[inline]
-            pub fn cc1e(&mut self) -> _CC1EW {
-                _CC1EW { w: self }
-            }
-        }
-    }
-    #[doc = "counter"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "counter"]
-    pub mod cnt {
-        #[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::CNT {
-            #[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 = r" Value of the field"]
-        pub struct CNTR {
-            bits: u16,
-        }
-        impl CNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&self) -> CNTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNTR { bits }
-            }
-        }
-        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 0:15 - counter value"]
-            #[inline]
-            pub fn cnt(&mut self) -> _CNTW {
-                _CNTW { w: self }
-            }
-        }
-    }
-    #[doc = "prescaler"]
-    pub struct PSC {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "prescaler"]
-    pub mod psc {
-        #[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::PSC {
-            #[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 = r" Value of the field"]
-        pub struct PSCR {
-            bits: u16,
-        }
-        impl PSCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PSCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&self) -> PSCR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PSCR { bits }
-            }
-        }
-        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 0:15 - Prescaler value"]
-            #[inline]
-            pub fn psc(&mut self) -> _PSCW {
-                _PSCW { w: self }
-            }
-        }
-    }
-    #[doc = "auto-reload register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "auto-reload register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARRR {
-            bits: u16,
-        }
-        impl ARRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&self) -> ARRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARRR { bits }
-            }
-        }
-        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 0:15 - Auto-reload value"]
-            #[inline]
-            pub fn arr(&mut self) -> _ARRW {
-                _ARRW { w: self }
-            }
-        }
-    }
-    #[doc = "capture/compare register 1"]
-    pub struct CCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "capture/compare register 1"]
-    pub mod ccr1 {
-        #[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::CCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CCR1R {
-            bits: u16,
-        }
-        impl CCR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CCR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&self) -> CCR1R {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CCR1R { bits }
-            }
-        }
-        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 0:15 - Capture/Compare 1 value"]
-            #[inline]
-            pub fn ccr1(&mut self) -> _CCR1W {
-                _CCR1W { w: self }
-            }
-        }
-    }
-}
-#[doc = "TIM14"]
-pub struct TIM14 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for TIM14 {}
-impl TIM14 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const tim13::RegisterBlock {
-        0x4000_2000 as *const _
-    }
-}
-impl Deref for TIM14 {
-    type Target = tim13::RegisterBlock;
-    fn deref(&self) -> &tim13::RegisterBlock {
-        unsafe { &*TIM14::ptr() }
-    }
-}
-#[doc = "Random number generator"]
-pub struct RNG {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for RNG {}
-impl RNG {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const rng::RegisterBlock {
-        0x5006_0800 as *const _
-    }
-}
-impl Deref for RNG {
-    type Target = rng::RegisterBlock;
-    fn deref(&self) -> &rng::RegisterBlock {
-        unsafe { &*RNG::ptr() }
-    }
-}
-#[doc = "Random number generator"]
-pub mod rng {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register"]
-        pub cr: CR,
-        #[doc = "0x04 - status register"]
-        pub sr: SR,
-        #[doc = "0x08 - data register"]
-        pub dr: DR,
-    }
-    #[doc = "control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct IER {
-            bits: bool,
-        }
-        impl IER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RNGENR {
-            bits: bool,
-        }
-        impl RNGENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _IEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RNGENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RNGENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 3 - Interrupt enable"]
-            #[inline]
-            pub fn ie(&self) -> IER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IER { bits }
-            }
-            #[doc = "Bit 2 - Random number generator enable"]
-            #[inline]
-            pub fn rngen(&self) -> RNGENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RNGENR { bits }
-            }
-        }
-        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 3 - Interrupt enable"]
-            #[inline]
-            pub fn ie(&mut self) -> _IEW {
-                _IEW { w: self }
-            }
-            #[doc = "Bit 2 - Random number generator enable"]
-            #[inline]
-            pub fn rngen(&mut self) -> _RNGENW {
-                _RNGENW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct SEISR {
-            bits: bool,
-        }
-        impl SEISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CEISR {
-            bits: bool,
-        }
-        impl CEISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SECSR {
-            bits: bool,
-        }
-        impl SECSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CECSR {
-            bits: bool,
-        }
-        impl CECSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DRDYR {
-            bits: bool,
-        }
-        impl DRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SEISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SEISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CEISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CEISW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - Seed error interrupt status"]
-            #[inline]
-            pub fn seis(&self) -> SEISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SEISR { bits }
-            }
-            #[doc = "Bit 5 - Clock error interrupt status"]
-            #[inline]
-            pub fn ceis(&self) -> CEISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CEISR { bits }
-            }
-            #[doc = "Bit 2 - Seed error current status"]
-            #[inline]
-            pub fn secs(&self) -> SECSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SECSR { bits }
-            }
-            #[doc = "Bit 1 - Clock error current status"]
-            #[inline]
-            pub fn cecs(&self) -> CECSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CECSR { bits }
-            }
-            #[doc = "Bit 0 - Data ready"]
-            #[inline]
-            pub fn drdy(&self) -> DRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DRDYR { bits }
-            }
-        }
-        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 6 - Seed error interrupt status"]
-            #[inline]
-            pub fn seis(&mut self) -> _SEISW {
-                _SEISW { w: self }
-            }
-            #[doc = "Bit 5 - Clock error interrupt status"]
-            #[inline]
-            pub fn ceis(&mut self) -> _CEISW {
-                _CEISW { w: self }
-            }
-        }
-    }
-    #[doc = "data register"]
-    pub struct DR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register"]
-    pub mod dr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RNDATAR {
-            bits: u32,
-        }
-        impl RNDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:31 - Random data"]
-            #[inline]
-            pub fn rndata(&self) -> RNDATAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                RNDATAR { bits }
-            }
-        }
-    }
-}
-#[doc = "Controller area network"]
-pub struct CAN1 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for CAN1 {}
-impl CAN1 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const can1::RegisterBlock {
-        0x4000_6400 as *const _
-    }
-}
-impl Deref for CAN1 {
-    type Target = can1::RegisterBlock;
-    fn deref(&self) -> &can1::RegisterBlock {
-        unsafe { &*CAN1::ptr() }
-    }
-}
-#[doc = "Controller area network"]
-pub mod can1 {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - master control register"]
-        pub mcr: MCR,
-        #[doc = "0x04 - master status register"]
-        pub msr: MSR,
-        #[doc = "0x08 - transmit status register"]
-        pub tsr: TSR,
-        #[doc = "0x0c - receive FIFO 0 register"]
-        pub rf0r: RF0R,
-        #[doc = "0x10 - receive FIFO 1 register"]
-        pub rf1r: RF1R,
-        #[doc = "0x14 - interrupt enable register"]
-        pub ier: IER,
-        #[doc = "0x18 - interrupt enable register"]
-        pub esr: ESR,
-        #[doc = "0x1c - bit timing register"]
-        pub btr: BTR,
-        _reserved0: [u8; 352usize],
-        #[doc = "0x180 - TX mailbox identifier register"]
-        pub ti0r: TI0R,
-        #[doc = "0x184 - mailbox data length control and time stamp register"]
-        pub tdt0r: TDT0R,
-        #[doc = "0x188 - mailbox data low register"]
-        pub tdl0r: TDL0R,
-        #[doc = "0x18c - mailbox data high register"]
-        pub tdh0r: TDH0R,
-        #[doc = "0x190 - mailbox identifier register"]
-        pub ti1r: TI1R,
-        #[doc = "0x194 - mailbox data length control and time stamp register"]
-        pub tdt1r: TDT1R,
-        #[doc = "0x198 - mailbox data low register"]
-        pub tdl1r: TDL1R,
-        #[doc = "0x19c - mailbox data high register"]
-        pub tdh1r: TDH1R,
-        #[doc = "0x1a0 - mailbox identifier register"]
-        pub ti2r: TI2R,
-        #[doc = "0x1a4 - mailbox data length control and time stamp register"]
-        pub tdt2r: TDT2R,
-        #[doc = "0x1a8 - mailbox data low register"]
-        pub tdl2r: TDL2R,
-        #[doc = "0x1ac - mailbox data high register"]
-        pub tdh2r: TDH2R,
-        #[doc = "0x1b0 - receive FIFO mailbox identifier register"]
-        pub ri0r: RI0R,
-        #[doc = "0x1b4 - mailbox data high register"]
-        pub rdt0r: RDT0R,
-        #[doc = "0x1b8 - mailbox data high register"]
-        pub rdl0r: RDL0R,
-        #[doc = "0x1bc - receive FIFO mailbox data high register"]
-        pub rdh0r: RDH0R,
-        #[doc = "0x1c0 - mailbox data high register"]
-        pub ri1r: RI1R,
-        #[doc = "0x1c4 - mailbox data high register"]
-        pub rdt1r: RDT1R,
-        #[doc = "0x1c8 - mailbox data high register"]
-        pub rdl1r: RDL1R,
-        #[doc = "0x1cc - mailbox data high register"]
-        pub rdh1r: RDH1R,
-        _reserved1: [u8; 48usize],
-        #[doc = "0x200 - filter master register"]
-        pub fmr: FMR,
-        #[doc = "0x204 - filter mode register"]
-        pub fm1r: FM1R,
-        _reserved2: [u8; 4usize],
-        #[doc = "0x20c - filter scale register"]
-        pub fs1r: FS1R,
-        _reserved3: [u8; 4usize],
-        #[doc = "0x214 - filter FIFO assignment register"]
-        pub ffa1r: FFA1R,
-        _reserved4: [u8; 4usize],
-        #[doc = "0x21c - filter activation register"]
-        pub fa1r: FA1R,
-        _reserved5: [u8; 32usize],
-        #[doc = "0x240 - Filter bank 0 register 1"]
-        pub f0r1: F0R1,
-        #[doc = "0x244 - Filter bank 0 register 2"]
-        pub f0r2: F0R2,
-        #[doc = "0x248 - Filter bank 1 register 1"]
-        pub f1r1: F1R1,
-        #[doc = "0x24c - Filter bank 1 register 2"]
-        pub f1r2: F1R2,
-        #[doc = "0x250 - Filter bank 2 register 1"]
-        pub f2r1: F2R1,
-        #[doc = "0x254 - Filter bank 2 register 2"]
-        pub f2r2: F2R2,
-        #[doc = "0x258 - Filter bank 3 register 1"]
-        pub f3r1: F3R1,
-        #[doc = "0x25c - Filter bank 3 register 2"]
-        pub f3r2: F3R2,
-        #[doc = "0x260 - Filter bank 4 register 1"]
-        pub f4r1: F4R1,
-        #[doc = "0x264 - Filter bank 4 register 2"]
-        pub f4r2: F4R2,
-        #[doc = "0x268 - Filter bank 5 register 1"]
-        pub f5r1: F5R1,
-        #[doc = "0x26c - Filter bank 5 register 2"]
-        pub f5r2: F5R2,
-        #[doc = "0x270 - Filter bank 6 register 1"]
-        pub f6r1: F6R1,
-        #[doc = "0x274 - Filter bank 6 register 2"]
-        pub f6r2: F6R2,
-        #[doc = "0x278 - Filter bank 7 register 1"]
-        pub f7r1: F7R1,
-        #[doc = "0x27c - Filter bank 7 register 2"]
-        pub f7r2: F7R2,
-        #[doc = "0x280 - Filter bank 8 register 1"]
-        pub f8r1: F8R1,
-        #[doc = "0x284 - Filter bank 8 register 2"]
-        pub f8r2: F8R2,
-        #[doc = "0x288 - Filter bank 9 register 1"]
-        pub f9r1: F9R1,
-        #[doc = "0x28c - Filter bank 9 register 2"]
-        pub f9r2: F9R2,
-        #[doc = "0x290 - Filter bank 10 register 1"]
-        pub f10r1: F10R1,
-        #[doc = "0x294 - Filter bank 10 register 2"]
-        pub f10r2: F10R2,
-        #[doc = "0x298 - Filter bank 11 register 1"]
-        pub f11r1: F11R1,
-        #[doc = "0x29c - Filter bank 11 register 2"]
-        pub f11r2: F11R2,
-        #[doc = "0x2a0 - Filter bank 4 register 1"]
-        pub f12r1: F12R1,
-        #[doc = "0x2a4 - Filter bank 12 register 2"]
-        pub f12r2: F12R2,
-        #[doc = "0x2a8 - Filter bank 13 register 1"]
-        pub f13r1: F13R1,
-        #[doc = "0x2ac - Filter bank 13 register 2"]
-        pub f13r2: F13R2,
-        #[doc = "0x2b0 - Filter bank 14 register 1"]
-        pub f14r1: F14R1,
-        #[doc = "0x2b4 - Filter bank 14 register 2"]
-        pub f14r2: F14R2,
-        #[doc = "0x2b8 - Filter bank 15 register 1"]
-        pub f15r1: F15R1,
-        #[doc = "0x2bc - Filter bank 15 register 2"]
-        pub f15r2: F15R2,
-        #[doc = "0x2c0 - Filter bank 16 register 1"]
-        pub f16r1: F16R1,
-        #[doc = "0x2c4 - Filter bank 16 register 2"]
-        pub f16r2: F16R2,
-        #[doc = "0x2c8 - Filter bank 17 register 1"]
-        pub f17r1: F17R1,
-        #[doc = "0x2cc - Filter bank 17 register 2"]
-        pub f17r2: F17R2,
-        #[doc = "0x2d0 - Filter bank 18 register 1"]
-        pub f18r1: F18R1,
-        #[doc = "0x2d4 - Filter bank 18 register 2"]
-        pub f18r2: F18R2,
-        #[doc = "0x2d8 - Filter bank 19 register 1"]
-        pub f19r1: F19R1,
-        #[doc = "0x2dc - Filter bank 19 register 2"]
-        pub f19r2: F19R2,
-        #[doc = "0x2e0 - Filter bank 20 register 1"]
-        pub f20r1: F20R1,
-        #[doc = "0x2e4 - Filter bank 20 register 2"]
-        pub f20r2: F20R2,
-        #[doc = "0x2e8 - Filter bank 21 register 1"]
-        pub f21r1: F21R1,
-        #[doc = "0x2ec - Filter bank 21 register 2"]
-        pub f21r2: F21R2,
-        #[doc = "0x2f0 - Filter bank 22 register 1"]
-        pub f22r1: F22R1,
-        #[doc = "0x2f4 - Filter bank 22 register 2"]
-        pub f22r2: F22R2,
-        #[doc = "0x2f8 - Filter bank 23 register 1"]
-        pub f23r1: F23R1,
-        #[doc = "0x2fc - Filter bank 23 register 2"]
-        pub f23r2: F23R2,
-        #[doc = "0x300 - Filter bank 24 register 1"]
-        pub f24r1: F24R1,
-        #[doc = "0x304 - Filter bank 24 register 2"]
-        pub f24r2: F24R2,
-        #[doc = "0x308 - Filter bank 25 register 1"]
-        pub f25r1: F25R1,
-        #[doc = "0x30c - Filter bank 25 register 2"]
-        pub f25r2: F25R2,
-        #[doc = "0x310 - Filter bank 26 register 1"]
-        pub f26r1: F26R1,
-        #[doc = "0x314 - Filter bank 26 register 2"]
-        pub f26r2: F26R2,
-        #[doc = "0x318 - Filter bank 27 register 1"]
-        pub f27r1: F27R1,
-        #[doc = "0x31c - Filter bank 27 register 2"]
-        pub f27r2: F27R2,
-    }
-    #[doc = "master control register"]
-    pub struct MCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "master control register"]
-    pub mod mcr {
-        #[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::MCR {
-            #[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 = r" Value of the field"]
-        pub struct DBFR {
-            bits: bool,
-        }
-        impl DBFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RESETR {
-            bits: bool,
-        }
-        impl RESETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TTCMR {
-            bits: bool,
-        }
-        impl TTCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ABOMR {
-            bits: bool,
-        }
-        impl ABOMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AWUMR {
-            bits: bool,
-        }
-        impl AWUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NARTR {
-            bits: bool,
-        }
-        impl NARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RFLMR {
-            bits: bool,
-        }
-        impl RFLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFPR {
-            bits: bool,
-        }
-        impl TXFPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SLEEPR {
-            bits: bool,
-        }
-        impl SLEEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INRQR {
-            bits: bool,
-        }
-        impl INRQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _DBFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RESETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RESETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TTCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TTCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ABOMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ABOMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AWUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AWUMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RFLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RFLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SLEEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SLEEPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _INRQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INRQW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 16 - DBF"]
-            #[inline]
-            pub fn dbf(&self) -> DBFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBFR { bits }
-            }
-            #[doc = "Bit 15 - RESET"]
-            #[inline]
-            pub fn reset(&self) -> RESETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RESETR { bits }
-            }
-            #[doc = "Bit 7 - TTCM"]
-            #[inline]
-            pub fn ttcm(&self) -> TTCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TTCMR { bits }
-            }
-            #[doc = "Bit 6 - ABOM"]
-            #[inline]
-            pub fn abom(&self) -> ABOMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ABOMR { bits }
-            }
-            #[doc = "Bit 5 - AWUM"]
-            #[inline]
-            pub fn awum(&self) -> AWUMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AWUMR { bits }
-            }
-            #[doc = "Bit 4 - NART"]
-            #[inline]
-            pub fn nart(&self) -> NARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NARTR { bits }
-            }
-            #[doc = "Bit 3 - RFLM"]
-            #[inline]
-            pub fn rflm(&self) -> RFLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RFLMR { bits }
-            }
-            #[doc = "Bit 2 - TXFP"]
-            #[inline]
-            pub fn txfp(&self) -> TXFPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFPR { bits }
-            }
-            #[doc = "Bit 1 - SLEEP"]
-            #[inline]
-            pub fn sleep(&self) -> SLEEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SLEEPR { bits }
-            }
-            #[doc = "Bit 0 - INRQ"]
-            #[inline]
-            pub fn inrq(&self) -> INRQR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INRQR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0001_0002 }
-            }
-            #[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 16 - DBF"]
-            #[inline]
-            pub fn dbf(&mut self) -> _DBFW {
-                _DBFW { w: self }
-            }
-            #[doc = "Bit 15 - RESET"]
-            #[inline]
-            pub fn reset(&mut self) -> _RESETW {
-                _RESETW { w: self }
-            }
-            #[doc = "Bit 7 - TTCM"]
-            #[inline]
-            pub fn ttcm(&mut self) -> _TTCMW {
-                _TTCMW { w: self }
-            }
-            #[doc = "Bit 6 - ABOM"]
-            #[inline]
-            pub fn abom(&mut self) -> _ABOMW {
-                _ABOMW { w: self }
-            }
-            #[doc = "Bit 5 - AWUM"]
-            #[inline]
-            pub fn awum(&mut self) -> _AWUMW {
-                _AWUMW { w: self }
-            }
-            #[doc = "Bit 4 - NART"]
-            #[inline]
-            pub fn nart(&mut self) -> _NARTW {
-                _NARTW { w: self }
-            }
-            #[doc = "Bit 3 - RFLM"]
-            #[inline]
-            pub fn rflm(&mut self) -> _RFLMW {
-                _RFLMW { w: self }
-            }
-            #[doc = "Bit 2 - TXFP"]
-            #[inline]
-            pub fn txfp(&mut self) -> _TXFPW {
-                _TXFPW { w: self }
-            }
-            #[doc = "Bit 1 - SLEEP"]
-            #[inline]
-            pub fn sleep(&mut self) -> _SLEEPW {
-                _SLEEPW { w: self }
-            }
-            #[doc = "Bit 0 - INRQ"]
-            #[inline]
-            pub fn inrq(&mut self) -> _INRQW {
-                _INRQW { w: self }
-            }
-        }
-    }
-    #[doc = "master status register"]
-    pub struct MSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "master status register"]
-    pub mod msr {
-        #[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::MSR {
-            #[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 = r" Value of the field"]
-        pub struct RXR {
-            bits: bool,
-        }
-        impl RXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SAMPR {
-            bits: bool,
-        }
-        impl SAMPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXMR {
-            bits: bool,
-        }
-        impl RXMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXMR {
-            bits: bool,
-        }
-        impl TXMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SLAKIR {
-            bits: bool,
-        }
-        impl SLAKIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WKUIR {
-            bits: bool,
-        }
-        impl WKUIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ERRIR {
-            bits: bool,
-        }
-        impl ERRIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SLAKR {
-            bits: bool,
-        }
-        impl SLAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INAKR {
-            bits: bool,
-        }
-        impl INAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SLAKIW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SLAKIW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WKUIW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WKUIW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ERRIW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ERRIW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 11 - RX"]
-            #[inline]
-            pub fn rx(&self) -> RXR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXR { bits }
-            }
-            #[doc = "Bit 10 - SAMP"]
-            #[inline]
-            pub fn samp(&self) -> SAMPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SAMPR { bits }
-            }
-            #[doc = "Bit 9 - RXM"]
-            #[inline]
-            pub fn rxm(&self) -> RXMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXMR { bits }
-            }
-            #[doc = "Bit 8 - TXM"]
-            #[inline]
-            pub fn txm(&self) -> TXMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXMR { bits }
-            }
-            #[doc = "Bit 4 - SLAKI"]
-            #[inline]
-            pub fn slaki(&self) -> SLAKIR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SLAKIR { bits }
-            }
-            #[doc = "Bit 3 - WKUI"]
-            #[inline]
-            pub fn wkui(&self) -> WKUIR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WKUIR { bits }
-            }
-            #[doc = "Bit 2 - ERRI"]
-            #[inline]
-            pub fn erri(&self) -> ERRIR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ERRIR { bits }
-            }
-            #[doc = "Bit 1 - SLAK"]
-            #[inline]
-            pub fn slak(&self) -> SLAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SLAKR { bits }
-            }
-            #[doc = "Bit 0 - INAK"]
-            #[inline]
-            pub fn inak(&self) -> INAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INAKR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0c02 }
-            }
-            #[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 4 - SLAKI"]
-            #[inline]
-            pub fn slaki(&mut self) -> _SLAKIW {
-                _SLAKIW { w: self }
-            }
-            #[doc = "Bit 3 - WKUI"]
-            #[inline]
-            pub fn wkui(&mut self) -> _WKUIW {
-                _WKUIW { w: self }
-            }
-            #[doc = "Bit 2 - ERRI"]
-            #[inline]
-            pub fn erri(&mut self) -> _ERRIW {
-                _ERRIW { w: self }
-            }
-        }
-    }
-    #[doc = "transmit status register"]
-    pub struct TSR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "transmit status register"]
-    pub mod tsr {
-        #[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::TSR {
-            #[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 = r" Value of the field"]
-        pub struct LOW2R {
-            bits: bool,
-        }
-        impl LOW2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LOW1R {
-            bits: bool,
-        }
-        impl LOW1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LOW0R {
-            bits: bool,
-        }
-        impl LOW0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TME2R {
-            bits: bool,
-        }
-        impl TME2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TME1R {
-            bits: bool,
-        }
-        impl TME1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TME0R {
-            bits: bool,
-        }
-        impl TME0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CODER {
-            bits: u8,
-        }
-        impl CODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ABRQ2R {
-            bits: bool,
-        }
-        impl ABRQ2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TERR2R {
-            bits: bool,
-        }
-        impl TERR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALST2R {
-            bits: bool,
-        }
-        impl ALST2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXOK2R {
-            bits: bool,
-        }
-        impl TXOK2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RQCP2R {
-            bits: bool,
-        }
-        impl RQCP2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ABRQ1R {
-            bits: bool,
-        }
-        impl ABRQ1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TERR1R {
-            bits: bool,
-        }
-        impl TERR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALST1R {
-            bits: bool,
-        }
-        impl ALST1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXOK1R {
-            bits: bool,
-        }
-        impl TXOK1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RQCP1R {
-            bits: bool,
-        }
-        impl RQCP1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ABRQ0R {
-            bits: bool,
-        }
-        impl ABRQ0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TERR0R {
-            bits: bool,
-        }
-        impl TERR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALST0R {
-            bits: bool,
-        }
-        impl ALST0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXOK0R {
-            bits: bool,
-        }
-        impl TXOK0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RQCP0R {
-            bits: bool,
-        }
-        impl RQCP0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ABRQ2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ABRQ2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TERR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TERR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALST2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALST2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXOK2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXOK2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RQCP2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RQCP2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ABRQ1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ABRQ1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TERR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TERR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALST1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALST1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXOK1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXOK1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RQCP1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RQCP1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ABRQ0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ABRQ0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TERR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TERR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALST0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALST0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXOK0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXOK0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RQCP0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RQCP0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 31 - Lowest priority flag for mailbox 2"]
-            #[inline]
-            pub fn low2(&self) -> LOW2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LOW2R { bits }
-            }
-            #[doc = "Bit 30 - Lowest priority flag for mailbox 1"]
-            #[inline]
-            pub fn low1(&self) -> LOW1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LOW1R { bits }
-            }
-            #[doc = "Bit 29 - Lowest priority flag for mailbox 0"]
-            #[inline]
-            pub fn low0(&self) -> LOW0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LOW0R { bits }
-            }
-            #[doc = "Bit 28 - Lowest priority flag for mailbox 2"]
-            #[inline]
-            pub fn tme2(&self) -> TME2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TME2R { bits }
-            }
-            #[doc = "Bit 27 - Lowest priority flag for mailbox 1"]
-            #[inline]
-            pub fn tme1(&self) -> TME1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TME1R { bits }
-            }
-            #[doc = "Bit 26 - Lowest priority flag for mailbox 0"]
-            #[inline]
-            pub fn tme0(&self) -> TME0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TME0R { bits }
-            }
-            #[doc = "Bits 24:25 - CODE"]
-            #[inline]
-            pub fn code(&self) -> CODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CODER { bits }
-            }
-            #[doc = "Bit 23 - ABRQ2"]
-            #[inline]
-            pub fn abrq2(&self) -> ABRQ2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ABRQ2R { bits }
-            }
-            #[doc = "Bit 19 - TERR2"]
-            #[inline]
-            pub fn terr2(&self) -> TERR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TERR2R { bits }
-            }
-            #[doc = "Bit 18 - ALST2"]
-            #[inline]
-            pub fn alst2(&self) -> ALST2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALST2R { bits }
-            }
-            #[doc = "Bit 17 - TXOK2"]
-            #[inline]
-            pub fn txok2(&self) -> TXOK2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXOK2R { bits }
-            }
-            #[doc = "Bit 16 - RQCP2"]
-            #[inline]
-            pub fn rqcp2(&self) -> RQCP2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RQCP2R { bits }
-            }
-            #[doc = "Bit 15 - ABRQ1"]
-            #[inline]
-            pub fn abrq1(&self) -> ABRQ1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ABRQ1R { bits }
-            }
-            #[doc = "Bit 11 - TERR1"]
-            #[inline]
-            pub fn terr1(&self) -> TERR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TERR1R { bits }
-            }
-            #[doc = "Bit 10 - ALST1"]
-            #[inline]
-            pub fn alst1(&self) -> ALST1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALST1R { bits }
-            }
-            #[doc = "Bit 9 - TXOK1"]
-            #[inline]
-            pub fn txok1(&self) -> TXOK1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXOK1R { bits }
-            }
-            #[doc = "Bit 8 - RQCP1"]
-            #[inline]
-            pub fn rqcp1(&self) -> RQCP1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RQCP1R { bits }
-            }
-            #[doc = "Bit 7 - ABRQ0"]
-            #[inline]
-            pub fn abrq0(&self) -> ABRQ0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ABRQ0R { bits }
-            }
-            #[doc = "Bit 3 - TERR0"]
-            #[inline]
-            pub fn terr0(&self) -> TERR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TERR0R { bits }
-            }
-            #[doc = "Bit 2 - ALST0"]
-            #[inline]
-            pub fn alst0(&self) -> ALST0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALST0R { bits }
-            }
-            #[doc = "Bit 1 - TXOK0"]
-            #[inline]
-            pub fn txok0(&self) -> TXOK0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXOK0R { bits }
-            }
-            #[doc = "Bit 0 - RQCP0"]
-            #[inline]
-            pub fn rqcp0(&self) -> RQCP0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RQCP0R { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x1c00_0000 }
-            }
-            #[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 23 - ABRQ2"]
-            #[inline]
-            pub fn abrq2(&mut self) -> _ABRQ2W {
-                _ABRQ2W { w: self }
-            }
-            #[doc = "Bit 19 - TERR2"]
-            #[inline]
-            pub fn terr2(&mut self) -> _TERR2W {
-                _TERR2W { w: self }
-            }
-            #[doc = "Bit 18 - ALST2"]
-            #[inline]
-            pub fn alst2(&mut self) -> _ALST2W {
-                _ALST2W { w: self }
-            }
-            #[doc = "Bit 17 - TXOK2"]
-            #[inline]
-            pub fn txok2(&mut self) -> _TXOK2W {
-                _TXOK2W { w: self }
-            }
-            #[doc = "Bit 16 - RQCP2"]
-            #[inline]
-            pub fn rqcp2(&mut self) -> _RQCP2W {
-                _RQCP2W { w: self }
-            }
-            #[doc = "Bit 15 - ABRQ1"]
-            #[inline]
-            pub fn abrq1(&mut self) -> _ABRQ1W {
-                _ABRQ1W { w: self }
-            }
-            #[doc = "Bit 11 - TERR1"]
-            #[inline]
-            pub fn terr1(&mut self) -> _TERR1W {
-                _TERR1W { w: self }
-            }
-            #[doc = "Bit 10 - ALST1"]
-            #[inline]
-            pub fn alst1(&mut self) -> _ALST1W {
-                _ALST1W { w: self }
-            }
-            #[doc = "Bit 9 - TXOK1"]
-            #[inline]
-            pub fn txok1(&mut self) -> _TXOK1W {
-                _TXOK1W { w: self }
-            }
-            #[doc = "Bit 8 - RQCP1"]
-            #[inline]
-            pub fn rqcp1(&mut self) -> _RQCP1W {
-                _RQCP1W { w: self }
-            }
-            #[doc = "Bit 7 - ABRQ0"]
-            #[inline]
-            pub fn abrq0(&mut self) -> _ABRQ0W {
-                _ABRQ0W { w: self }
-            }
-            #[doc = "Bit 3 - TERR0"]
-            #[inline]
-            pub fn terr0(&mut self) -> _TERR0W {
-                _TERR0W { w: self }
-            }
-            #[doc = "Bit 2 - ALST0"]
-            #[inline]
-            pub fn alst0(&mut self) -> _ALST0W {
-                _ALST0W { w: self }
-            }
-            #[doc = "Bit 1 - TXOK0"]
-            #[inline]
-            pub fn txok0(&mut self) -> _TXOK0W {
-                _TXOK0W { w: self }
-            }
-            #[doc = "Bit 0 - RQCP0"]
-            #[inline]
-            pub fn rqcp0(&mut self) -> _RQCP0W {
-                _RQCP0W { w: self }
-            }
-        }
-    }
-    #[doc = "receive FIFO 0 register"]
-    pub struct RF0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "receive FIFO 0 register"]
-    pub mod rf0r {
-        #[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::RF0R {
-            #[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 = r" Value of the field"]
-        pub struct RFOM0R {
-            bits: bool,
-        }
-        impl RFOM0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FOVR0R {
-            bits: bool,
-        }
-        impl FOVR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FULL0R {
-            bits: bool,
-        }
-        impl FULL0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FMP0R {
-            bits: u8,
-        }
-        impl FMP0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RFOM0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RFOM0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FOVR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FOVR0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FULL0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FULL0W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 5 - RFOM0"]
-            #[inline]
-            pub fn rfom0(&self) -> RFOM0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RFOM0R { bits }
-            }
-            #[doc = "Bit 4 - FOVR0"]
-            #[inline]
-            pub fn fovr0(&self) -> FOVR0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FOVR0R { bits }
-            }
-            #[doc = "Bit 3 - FULL0"]
-            #[inline]
-            pub fn full0(&self) -> FULL0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FULL0R { bits }
-            }
-            #[doc = "Bits 0:1 - FMP0"]
-            #[inline]
-            pub fn fmp0(&self) -> FMP0R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FMP0R { bits }
-            }
-        }
-        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 5 - RFOM0"]
-            #[inline]
-            pub fn rfom0(&mut self) -> _RFOM0W {
-                _RFOM0W { w: self }
-            }
-            #[doc = "Bit 4 - FOVR0"]
-            #[inline]
-            pub fn fovr0(&mut self) -> _FOVR0W {
-                _FOVR0W { w: self }
-            }
-            #[doc = "Bit 3 - FULL0"]
-            #[inline]
-            pub fn full0(&mut self) -> _FULL0W {
-                _FULL0W { w: self }
-            }
-        }
-    }
-    #[doc = "receive FIFO 1 register"]
-    pub struct RF1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "receive FIFO 1 register"]
-    pub mod rf1r {
-        #[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::RF1R {
-            #[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 = r" Value of the field"]
-        pub struct RFOM1R {
-            bits: bool,
-        }
-        impl RFOM1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FOVR1R {
-            bits: bool,
-        }
-        impl FOVR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FULL1R {
-            bits: bool,
-        }
-        impl FULL1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FMP1R {
-            bits: u8,
-        }
-        impl FMP1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RFOM1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RFOM1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FOVR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FOVR1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FULL1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FULL1W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 5 - RFOM1"]
-            #[inline]
-            pub fn rfom1(&self) -> RFOM1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RFOM1R { bits }
-            }
-            #[doc = "Bit 4 - FOVR1"]
-            #[inline]
-            pub fn fovr1(&self) -> FOVR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FOVR1R { bits }
-            }
-            #[doc = "Bit 3 - FULL1"]
-            #[inline]
-            pub fn full1(&self) -> FULL1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FULL1R { bits }
-            }
-            #[doc = "Bits 0:1 - FMP1"]
-            #[inline]
-            pub fn fmp1(&self) -> FMP1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FMP1R { bits }
-            }
-        }
-        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 5 - RFOM1"]
-            #[inline]
-            pub fn rfom1(&mut self) -> _RFOM1W {
-                _RFOM1W { w: self }
-            }
-            #[doc = "Bit 4 - FOVR1"]
-            #[inline]
-            pub fn fovr1(&mut self) -> _FOVR1W {
-                _FOVR1W { w: self }
-            }
-            #[doc = "Bit 3 - FULL1"]
-            #[inline]
-            pub fn full1(&mut self) -> _FULL1W {
-                _FULL1W { w: self }
-            }
-        }
-    }
-    #[doc = "interrupt enable register"]
-    pub struct IER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt enable register"]
-    pub mod ier {
-        #[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::IER {
-            #[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 = r" Value of the field"]
-        pub struct SLKIER {
-            bits: bool,
-        }
-        impl SLKIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WKUIER {
-            bits: bool,
-        }
-        impl WKUIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ERRIER {
-            bits: bool,
-        }
-        impl ERRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LECIER {
-            bits: bool,
-        }
-        impl LECIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BOFIER {
-            bits: bool,
-        }
-        impl BOFIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPVIER {
-            bits: bool,
-        }
-        impl EPVIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EWGIER {
-            bits: bool,
-        }
-        impl EWGIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FOVIE1R {
-            bits: bool,
-        }
-        impl FOVIE1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFIE1R {
-            bits: bool,
-        }
-        impl FFIE1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FMPIE1R {
-            bits: bool,
-        }
-        impl FMPIE1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FOVIE0R {
-            bits: bool,
-        }
-        impl FOVIE0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFIE0R {
-            bits: bool,
-        }
-        impl FFIE0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FMPIE0R {
-            bits: bool,
-        }
-        impl FMPIE0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TMEIER {
-            bits: bool,
-        }
-        impl TMEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SLKIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SLKIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WKUIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WKUIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ERRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ERRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LECIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LECIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BOFIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BOFIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPVIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPVIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EWGIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EWGIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FOVIE1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FOVIE1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFIE1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFIE1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FMPIE1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FMPIE1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FOVIE0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FOVIE0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFIE0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFIE0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FMPIE0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FMPIE0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TMEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TMEIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 17 - SLKIE"]
-            #[inline]
-            pub fn slkie(&self) -> SLKIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SLKIER { bits }
-            }
-            #[doc = "Bit 16 - WKUIE"]
-            #[inline]
-            pub fn wkuie(&self) -> WKUIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WKUIER { bits }
-            }
-            #[doc = "Bit 15 - ERRIE"]
-            #[inline]
-            pub fn errie(&self) -> ERRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ERRIER { bits }
-            }
-            #[doc = "Bit 11 - LECIE"]
-            #[inline]
-            pub fn lecie(&self) -> LECIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LECIER { bits }
-            }
-            #[doc = "Bit 10 - BOFIE"]
-            #[inline]
-            pub fn bofie(&self) -> BOFIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BOFIER { bits }
-            }
-            #[doc = "Bit 9 - EPVIE"]
-            #[inline]
-            pub fn epvie(&self) -> EPVIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPVIER { bits }
-            }
-            #[doc = "Bit 8 - EWGIE"]
-            #[inline]
-            pub fn ewgie(&self) -> EWGIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EWGIER { bits }
-            }
-            #[doc = "Bit 6 - FOVIE1"]
-            #[inline]
-            pub fn fovie1(&self) -> FOVIE1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FOVIE1R { bits }
-            }
-            #[doc = "Bit 5 - FFIE1"]
-            #[inline]
-            pub fn ffie1(&self) -> FFIE1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFIE1R { bits }
-            }
-            #[doc = "Bit 4 - FMPIE1"]
-            #[inline]
-            pub fn fmpie1(&self) -> FMPIE1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FMPIE1R { bits }
-            }
-            #[doc = "Bit 3 - FOVIE0"]
-            #[inline]
-            pub fn fovie0(&self) -> FOVIE0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FOVIE0R { bits }
-            }
-            #[doc = "Bit 2 - FFIE0"]
-            #[inline]
-            pub fn ffie0(&self) -> FFIE0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFIE0R { bits }
-            }
-            #[doc = "Bit 1 - FMPIE0"]
-            #[inline]
-            pub fn fmpie0(&self) -> FMPIE0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FMPIE0R { bits }
-            }
-            #[doc = "Bit 0 - TMEIE"]
-            #[inline]
-            pub fn tmeie(&self) -> TMEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TMEIER { bits }
-            }
-        }
-        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 17 - SLKIE"]
-            #[inline]
-            pub fn slkie(&mut self) -> _SLKIEW {
-                _SLKIEW { w: self }
-            }
-            #[doc = "Bit 16 - WKUIE"]
-            #[inline]
-            pub fn wkuie(&mut self) -> _WKUIEW {
-                _WKUIEW { w: self }
-            }
-            #[doc = "Bit 15 - ERRIE"]
-            #[inline]
-            pub fn errie(&mut self) -> _ERRIEW {
-                _ERRIEW { w: self }
-            }
-            #[doc = "Bit 11 - LECIE"]
-            #[inline]
-            pub fn lecie(&mut self) -> _LECIEW {
-                _LECIEW { w: self }
-            }
-            #[doc = "Bit 10 - BOFIE"]
-            #[inline]
-            pub fn bofie(&mut self) -> _BOFIEW {
-                _BOFIEW { w: self }
-            }
-            #[doc = "Bit 9 - EPVIE"]
-            #[inline]
-            pub fn epvie(&mut self) -> _EPVIEW {
-                _EPVIEW { w: self }
-            }
-            #[doc = "Bit 8 - EWGIE"]
-            #[inline]
-            pub fn ewgie(&mut self) -> _EWGIEW {
-                _EWGIEW { w: self }
-            }
-            #[doc = "Bit 6 - FOVIE1"]
-            #[inline]
-            pub fn fovie1(&mut self) -> _FOVIE1W {
-                _FOVIE1W { w: self }
-            }
-            #[doc = "Bit 5 - FFIE1"]
-            #[inline]
-            pub fn ffie1(&mut self) -> _FFIE1W {
-                _FFIE1W { w: self }
-            }
-            #[doc = "Bit 4 - FMPIE1"]
-            #[inline]
-            pub fn fmpie1(&mut self) -> _FMPIE1W {
-                _FMPIE1W { w: self }
-            }
-            #[doc = "Bit 3 - FOVIE0"]
-            #[inline]
-            pub fn fovie0(&mut self) -> _FOVIE0W {
-                _FOVIE0W { w: self }
-            }
-            #[doc = "Bit 2 - FFIE0"]
-            #[inline]
-            pub fn ffie0(&mut self) -> _FFIE0W {
-                _FFIE0W { w: self }
-            }
-            #[doc = "Bit 1 - FMPIE0"]
-            #[inline]
-            pub fn fmpie0(&mut self) -> _FMPIE0W {
-                _FMPIE0W { w: self }
-            }
-            #[doc = "Bit 0 - TMEIE"]
-            #[inline]
-            pub fn tmeie(&mut self) -> _TMEIEW {
-                _TMEIEW { w: self }
-            }
-        }
-    }
-    #[doc = "interrupt enable register"]
-    pub struct ESR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "interrupt enable register"]
-    pub mod esr {
-        #[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::ESR {
-            #[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 = r" Value of the field"]
-        pub struct RECR {
-            bits: u8,
-        }
-        impl RECR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TECR {
-            bits: u8,
-        }
-        impl TECR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct LECR {
-            bits: u8,
-        }
-        impl LECR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BOFFR {
-            bits: bool,
-        }
-        impl BOFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPVFR {
-            bits: bool,
-        }
-        impl EPVFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EWGFR {
-            bits: bool,
-        }
-        impl EWGFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LECW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LECW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                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 24:31 - REC"]
-            #[inline]
-            pub fn rec(&self) -> RECR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RECR { bits }
-            }
-            #[doc = "Bits 16:23 - TEC"]
-            #[inline]
-            pub fn tec(&self) -> TECR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TECR { bits }
-            }
-            #[doc = "Bits 4:6 - LEC"]
-            #[inline]
-            pub fn lec(&self) -> LECR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                LECR { bits }
-            }
-            #[doc = "Bit 2 - BOFF"]
-            #[inline]
-            pub fn boff(&self) -> BOFFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BOFFR { bits }
-            }
-            #[doc = "Bit 1 - EPVF"]
-            #[inline]
-            pub fn epvf(&self) -> EPVFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPVFR { bits }
-            }
-            #[doc = "Bit 0 - EWGF"]
-            #[inline]
-            pub fn ewgf(&self) -> EWGFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EWGFR { bits }
-            }
-        }
-        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 4:6 - LEC"]
-            #[inline]
-            pub fn lec(&mut self) -> _LECW {
-                _LECW { w: self }
-            }
-        }
-    }
-    #[doc = "bit timing register"]
-    pub struct BTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "bit timing register"]
-    pub mod btr {
-        #[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::BTR {
-            #[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 = r" Value of the field"]
-        pub struct SILMR {
-            bits: bool,
-        }
-        impl SILMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LBKMR {
-            bits: bool,
-        }
-        impl LBKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SJWR {
-            bits: u8,
-        }
-        impl SJWR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TS2R {
-            bits: u8,
-        }
-        impl TS2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TS1R {
-            bits: u8,
-        }
-        impl TS1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BRPR {
-            bits: u16,
-        }
-        impl BRPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SILMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SILMW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _LBKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LBKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SJWW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SJWW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TS2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TS2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TS1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TS1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BRPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BRPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                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 = "Bit 31 - SILM"]
-            #[inline]
-            pub fn silm(&self) -> SILMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SILMR { bits }
-            }
-            #[doc = "Bit 30 - LBKM"]
-            #[inline]
-            pub fn lbkm(&self) -> LBKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LBKMR { bits }
-            }
-            #[doc = "Bits 24:25 - SJW"]
-            #[inline]
-            pub fn sjw(&self) -> SJWR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SJWR { bits }
-            }
-            #[doc = "Bits 20:22 - TS2"]
-            #[inline]
-            pub fn ts2(&self) -> TS2R {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TS2R { bits }
-            }
-            #[doc = "Bits 16:19 - TS1"]
-            #[inline]
-            pub fn ts1(&self) -> TS1R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TS1R { bits }
-            }
-            #[doc = "Bits 0:9 - BRP"]
-            #[inline]
-            pub fn brp(&self) -> BRPR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                BRPR { bits }
-            }
-        }
-        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 31 - SILM"]
-            #[inline]
-            pub fn silm(&mut self) -> _SILMW {
-                _SILMW { w: self }
-            }
-            #[doc = "Bit 30 - LBKM"]
-            #[inline]
-            pub fn lbkm(&mut self) -> _LBKMW {
-                _LBKMW { w: self }
-            }
-            #[doc = "Bits 24:25 - SJW"]
-            #[inline]
-            pub fn sjw(&mut self) -> _SJWW {
-                _SJWW { w: self }
-            }
-            #[doc = "Bits 20:22 - TS2"]
-            #[inline]
-            pub fn ts2(&mut self) -> _TS2W {
-                _TS2W { w: self }
-            }
-            #[doc = "Bits 16:19 - TS1"]
-            #[inline]
-            pub fn ts1(&mut self) -> _TS1W {
-                _TS1W { w: self }
-            }
-            #[doc = "Bits 0:9 - BRP"]
-            #[inline]
-            pub fn brp(&mut self) -> _BRPW {
-                _BRPW { w: self }
-            }
-        }
-    }
-    #[doc = "TX mailbox identifier register"]
-    pub struct TI0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "TX mailbox identifier register"]
-    pub mod ti0r {
-        #[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::TI0R {
-            #[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 = r" Value of the field"]
-        pub struct STIDR {
-            bits: u16,
-        }
-        impl STIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXIDR {
-            bits: u32,
-        }
-        impl EXIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IDER {
-            bits: bool,
-        }
-        impl IDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTRR {
-            bits: bool,
-        }
-        impl RTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXRQR {
-            bits: bool,
-        }
-        impl TXRQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _STIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0003_ffff;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXRQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXRQW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 21:31 - STID"]
-            #[inline]
-            pub fn stid(&self) -> STIDR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                STIDR { bits }
-            }
-            #[doc = "Bits 3:20 - EXID"]
-            #[inline]
-            pub fn exid(&self) -> EXIDR {
-                let bits = {
-                    const MASK: u32 = 0x0003_ffff;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXIDR { bits }
-            }
-            #[doc = "Bit 2 - IDE"]
-            #[inline]
-            pub fn ide(&self) -> IDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDER { bits }
-            }
-            #[doc = "Bit 1 - RTR"]
-            #[inline]
-            pub fn rtr(&self) -> RTRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTRR { bits }
-            }
-            #[doc = "Bit 0 - TXRQ"]
-            #[inline]
-            pub fn txrq(&self) -> TXRQR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXRQR { bits }
-            }
-        }
-        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 21:31 - STID"]
-            #[inline]
-            pub fn stid(&mut self) -> _STIDW {
-                _STIDW { w: self }
-            }
-            #[doc = "Bits 3:20 - EXID"]
-            #[inline]
-            pub fn exid(&mut self) -> _EXIDW {
-                _EXIDW { w: self }
-            }
-            #[doc = "Bit 2 - IDE"]
-            #[inline]
-            pub fn ide(&mut self) -> _IDEW {
-                _IDEW { w: self }
-            }
-            #[doc = "Bit 1 - RTR"]
-            #[inline]
-            pub fn rtr(&mut self) -> _RTRW {
-                _RTRW { w: self }
-            }
-            #[doc = "Bit 0 - TXRQ"]
-            #[inline]
-            pub fn txrq(&mut self) -> _TXRQW {
-                _TXRQW { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data length control and time stamp register"]
-    pub struct TDT0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data length control and time stamp register"]
-    pub mod tdt0r {
-        #[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::TDT0R {
-            #[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 = r" Value of the field"]
-        pub struct TIMER {
-            bits: u16,
-        }
-        impl TIMER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TGTR {
-            bits: bool,
-        }
-        impl TGTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DLCR {
-            bits: u8,
-        }
-        impl DLCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TIMEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TGTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DLCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DLCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 16:31 - TIME"]
-            #[inline]
-            pub fn time(&self) -> TIMER {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TIMER { bits }
-            }
-            #[doc = "Bit 8 - TGT"]
-            #[inline]
-            pub fn tgt(&self) -> TGTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TGTR { bits }
-            }
-            #[doc = "Bits 0:3 - DLC"]
-            #[inline]
-            pub fn dlc(&self) -> DLCR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DLCR { bits }
-            }
-        }
-        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 16:31 - TIME"]
-            #[inline]
-            pub fn time(&mut self) -> _TIMEW {
-                _TIMEW { w: self }
-            }
-            #[doc = "Bit 8 - TGT"]
-            #[inline]
-            pub fn tgt(&mut self) -> _TGTW {
-                _TGTW { w: self }
-            }
-            #[doc = "Bits 0:3 - DLC"]
-            #[inline]
-            pub fn dlc(&mut self) -> _DLCW {
-                _DLCW { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data low register"]
-    pub struct TDL0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data low register"]
-    pub mod tdl0r {
-        #[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::TDL0R {
-            #[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 = r" Value of the field"]
-        pub struct DATA3R {
-            bits: u8,
-        }
-        impl DATA3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA2R {
-            bits: u8,
-        }
-        impl DATA2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA1R {
-            bits: u8,
-        }
-        impl DATA1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA0R {
-            bits: u8,
-        }
-        impl DATA0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - DATA3"]
-            #[inline]
-            pub fn data3(&self) -> DATA3R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA3R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA2"]
-            #[inline]
-            pub fn data2(&self) -> DATA2R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA2R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA1"]
-            #[inline]
-            pub fn data1(&self) -> DATA1R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA1R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA0"]
-            #[inline]
-            pub fn data0(&self) -> DATA0R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA0R { bits }
-            }
-        }
-        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 24:31 - DATA3"]
-            #[inline]
-            pub fn data3(&mut self) -> _DATA3W {
-                _DATA3W { w: self }
-            }
-            #[doc = "Bits 16:23 - DATA2"]
-            #[inline]
-            pub fn data2(&mut self) -> _DATA2W {
-                _DATA2W { w: self }
-            }
-            #[doc = "Bits 8:15 - DATA1"]
-            #[inline]
-            pub fn data1(&mut self) -> _DATA1W {
-                _DATA1W { w: self }
-            }
-            #[doc = "Bits 0:7 - DATA0"]
-            #[inline]
-            pub fn data0(&mut self) -> _DATA0W {
-                _DATA0W { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct TDH0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod tdh0r {
-        #[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::TDH0R {
-            #[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 = r" Value of the field"]
-        pub struct DATA7R {
-            bits: u8,
-        }
-        impl DATA7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA6R {
-            bits: u8,
-        }
-        impl DATA6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA5R {
-            bits: u8,
-        }
-        impl DATA5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA4R {
-            bits: u8,
-        }
-        impl DATA4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - DATA7"]
-            #[inline]
-            pub fn data7(&self) -> DATA7R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA7R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA6"]
-            #[inline]
-            pub fn data6(&self) -> DATA6R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA6R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA5"]
-            #[inline]
-            pub fn data5(&self) -> DATA5R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA5R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA4"]
-            #[inline]
-            pub fn data4(&self) -> DATA4R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA4R { bits }
-            }
-        }
-        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 24:31 - DATA7"]
-            #[inline]
-            pub fn data7(&mut self) -> _DATA7W {
-                _DATA7W { w: self }
-            }
-            #[doc = "Bits 16:23 - DATA6"]
-            #[inline]
-            pub fn data6(&mut self) -> _DATA6W {
-                _DATA6W { w: self }
-            }
-            #[doc = "Bits 8:15 - DATA5"]
-            #[inline]
-            pub fn data5(&mut self) -> _DATA5W {
-                _DATA5W { w: self }
-            }
-            #[doc = "Bits 0:7 - DATA4"]
-            #[inline]
-            pub fn data4(&mut self) -> _DATA4W {
-                _DATA4W { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox identifier register"]
-    pub struct TI1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox identifier register"]
-    pub mod ti1r {
-        #[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::TI1R {
-            #[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 = r" Value of the field"]
-        pub struct STIDR {
-            bits: u16,
-        }
-        impl STIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXIDR {
-            bits: u32,
-        }
-        impl EXIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IDER {
-            bits: bool,
-        }
-        impl IDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTRR {
-            bits: bool,
-        }
-        impl RTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXRQR {
-            bits: bool,
-        }
-        impl TXRQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _STIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0003_ffff;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXRQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXRQW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 21:31 - STID"]
-            #[inline]
-            pub fn stid(&self) -> STIDR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                STIDR { bits }
-            }
-            #[doc = "Bits 3:20 - EXID"]
-            #[inline]
-            pub fn exid(&self) -> EXIDR {
-                let bits = {
-                    const MASK: u32 = 0x0003_ffff;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXIDR { bits }
-            }
-            #[doc = "Bit 2 - IDE"]
-            #[inline]
-            pub fn ide(&self) -> IDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDER { bits }
-            }
-            #[doc = "Bit 1 - RTR"]
-            #[inline]
-            pub fn rtr(&self) -> RTRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTRR { bits }
-            }
-            #[doc = "Bit 0 - TXRQ"]
-            #[inline]
-            pub fn txrq(&self) -> TXRQR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXRQR { bits }
-            }
-        }
-        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 21:31 - STID"]
-            #[inline]
-            pub fn stid(&mut self) -> _STIDW {
-                _STIDW { w: self }
-            }
-            #[doc = "Bits 3:20 - EXID"]
-            #[inline]
-            pub fn exid(&mut self) -> _EXIDW {
-                _EXIDW { w: self }
-            }
-            #[doc = "Bit 2 - IDE"]
-            #[inline]
-            pub fn ide(&mut self) -> _IDEW {
-                _IDEW { w: self }
-            }
-            #[doc = "Bit 1 - RTR"]
-            #[inline]
-            pub fn rtr(&mut self) -> _RTRW {
-                _RTRW { w: self }
-            }
-            #[doc = "Bit 0 - TXRQ"]
-            #[inline]
-            pub fn txrq(&mut self) -> _TXRQW {
-                _TXRQW { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data length control and time stamp register"]
-    pub struct TDT1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data length control and time stamp register"]
-    pub mod tdt1r {
-        #[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::TDT1R {
-            #[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 = r" Value of the field"]
-        pub struct TIMER {
-            bits: u16,
-        }
-        impl TIMER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TGTR {
-            bits: bool,
-        }
-        impl TGTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DLCR {
-            bits: u8,
-        }
-        impl DLCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TIMEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TGTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DLCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DLCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 16:31 - TIME"]
-            #[inline]
-            pub fn time(&self) -> TIMER {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TIMER { bits }
-            }
-            #[doc = "Bit 8 - TGT"]
-            #[inline]
-            pub fn tgt(&self) -> TGTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TGTR { bits }
-            }
-            #[doc = "Bits 0:3 - DLC"]
-            #[inline]
-            pub fn dlc(&self) -> DLCR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DLCR { bits }
-            }
-        }
-        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 16:31 - TIME"]
-            #[inline]
-            pub fn time(&mut self) -> _TIMEW {
-                _TIMEW { w: self }
-            }
-            #[doc = "Bit 8 - TGT"]
-            #[inline]
-            pub fn tgt(&mut self) -> _TGTW {
-                _TGTW { w: self }
-            }
-            #[doc = "Bits 0:3 - DLC"]
-            #[inline]
-            pub fn dlc(&mut self) -> _DLCW {
-                _DLCW { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data low register"]
-    pub struct TDL1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data low register"]
-    pub mod tdl1r {
-        #[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::TDL1R {
-            #[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 = r" Value of the field"]
-        pub struct DATA3R {
-            bits: u8,
-        }
-        impl DATA3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA2R {
-            bits: u8,
-        }
-        impl DATA2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA1R {
-            bits: u8,
-        }
-        impl DATA1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA0R {
-            bits: u8,
-        }
-        impl DATA0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - DATA3"]
-            #[inline]
-            pub fn data3(&self) -> DATA3R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA3R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA2"]
-            #[inline]
-            pub fn data2(&self) -> DATA2R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA2R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA1"]
-            #[inline]
-            pub fn data1(&self) -> DATA1R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA1R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA0"]
-            #[inline]
-            pub fn data0(&self) -> DATA0R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA0R { bits }
-            }
-        }
-        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 24:31 - DATA3"]
-            #[inline]
-            pub fn data3(&mut self) -> _DATA3W {
-                _DATA3W { w: self }
-            }
-            #[doc = "Bits 16:23 - DATA2"]
-            #[inline]
-            pub fn data2(&mut self) -> _DATA2W {
-                _DATA2W { w: self }
-            }
-            #[doc = "Bits 8:15 - DATA1"]
-            #[inline]
-            pub fn data1(&mut self) -> _DATA1W {
-                _DATA1W { w: self }
-            }
-            #[doc = "Bits 0:7 - DATA0"]
-            #[inline]
-            pub fn data0(&mut self) -> _DATA0W {
-                _DATA0W { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct TDH1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod tdh1r {
-        #[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::TDH1R {
-            #[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 = r" Value of the field"]
-        pub struct DATA7R {
-            bits: u8,
-        }
-        impl DATA7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA6R {
-            bits: u8,
-        }
-        impl DATA6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA5R {
-            bits: u8,
-        }
-        impl DATA5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA4R {
-            bits: u8,
-        }
-        impl DATA4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - DATA7"]
-            #[inline]
-            pub fn data7(&self) -> DATA7R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA7R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA6"]
-            #[inline]
-            pub fn data6(&self) -> DATA6R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA6R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA5"]
-            #[inline]
-            pub fn data5(&self) -> DATA5R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA5R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA4"]
-            #[inline]
-            pub fn data4(&self) -> DATA4R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA4R { bits }
-            }
-        }
-        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 24:31 - DATA7"]
-            #[inline]
-            pub fn data7(&mut self) -> _DATA7W {
-                _DATA7W { w: self }
-            }
-            #[doc = "Bits 16:23 - DATA6"]
-            #[inline]
-            pub fn data6(&mut self) -> _DATA6W {
-                _DATA6W { w: self }
-            }
-            #[doc = "Bits 8:15 - DATA5"]
-            #[inline]
-            pub fn data5(&mut self) -> _DATA5W {
-                _DATA5W { w: self }
-            }
-            #[doc = "Bits 0:7 - DATA4"]
-            #[inline]
-            pub fn data4(&mut self) -> _DATA4W {
-                _DATA4W { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox identifier register"]
-    pub struct TI2R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox identifier register"]
-    pub mod ti2r {
-        #[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::TI2R {
-            #[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 = r" Value of the field"]
-        pub struct STIDR {
-            bits: u16,
-        }
-        impl STIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXIDR {
-            bits: u32,
-        }
-        impl EXIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IDER {
-            bits: bool,
-        }
-        impl IDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTRR {
-            bits: bool,
-        }
-        impl RTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXRQR {
-            bits: bool,
-        }
-        impl TXRQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _STIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 21;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EXIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0003_ffff;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IDEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IDEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RTRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RTRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXRQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXRQW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 21:31 - STID"]
-            #[inline]
-            pub fn stid(&self) -> STIDR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                STIDR { bits }
-            }
-            #[doc = "Bits 3:20 - EXID"]
-            #[inline]
-            pub fn exid(&self) -> EXIDR {
-                let bits = {
-                    const MASK: u32 = 0x0003_ffff;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXIDR { bits }
-            }
-            #[doc = "Bit 2 - IDE"]
-            #[inline]
-            pub fn ide(&self) -> IDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDER { bits }
-            }
-            #[doc = "Bit 1 - RTR"]
-            #[inline]
-            pub fn rtr(&self) -> RTRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTRR { bits }
-            }
-            #[doc = "Bit 0 - TXRQ"]
-            #[inline]
-            pub fn txrq(&self) -> TXRQR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXRQR { bits }
-            }
-        }
-        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 21:31 - STID"]
-            #[inline]
-            pub fn stid(&mut self) -> _STIDW {
-                _STIDW { w: self }
-            }
-            #[doc = "Bits 3:20 - EXID"]
-            #[inline]
-            pub fn exid(&mut self) -> _EXIDW {
-                _EXIDW { w: self }
-            }
-            #[doc = "Bit 2 - IDE"]
-            #[inline]
-            pub fn ide(&mut self) -> _IDEW {
-                _IDEW { w: self }
-            }
-            #[doc = "Bit 1 - RTR"]
-            #[inline]
-            pub fn rtr(&mut self) -> _RTRW {
-                _RTRW { w: self }
-            }
-            #[doc = "Bit 0 - TXRQ"]
-            #[inline]
-            pub fn txrq(&mut self) -> _TXRQW {
-                _TXRQW { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data length control and time stamp register"]
-    pub struct TDT2R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data length control and time stamp register"]
-    pub mod tdt2r {
-        #[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::TDT2R {
-            #[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 = r" Value of the field"]
-        pub struct TIMER {
-            bits: u16,
-        }
-        impl TIMER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TGTR {
-            bits: bool,
-        }
-        impl TGTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DLCR {
-            bits: u8,
-        }
-        impl DLCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TIMEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TGTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TGTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DLCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DLCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 16:31 - TIME"]
-            #[inline]
-            pub fn time(&self) -> TIMER {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TIMER { bits }
-            }
-            #[doc = "Bit 8 - TGT"]
-            #[inline]
-            pub fn tgt(&self) -> TGTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TGTR { bits }
-            }
-            #[doc = "Bits 0:3 - DLC"]
-            #[inline]
-            pub fn dlc(&self) -> DLCR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DLCR { bits }
-            }
-        }
-        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 16:31 - TIME"]
-            #[inline]
-            pub fn time(&mut self) -> _TIMEW {
-                _TIMEW { w: self }
-            }
-            #[doc = "Bit 8 - TGT"]
-            #[inline]
-            pub fn tgt(&mut self) -> _TGTW {
-                _TGTW { w: self }
-            }
-            #[doc = "Bits 0:3 - DLC"]
-            #[inline]
-            pub fn dlc(&mut self) -> _DLCW {
-                _DLCW { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data low register"]
-    pub struct TDL2R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data low register"]
-    pub mod tdl2r {
-        #[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::TDL2R {
-            #[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 = r" Value of the field"]
-        pub struct DATA3R {
-            bits: u8,
-        }
-        impl DATA3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA2R {
-            bits: u8,
-        }
-        impl DATA2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA1R {
-            bits: u8,
-        }
-        impl DATA1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA0R {
-            bits: u8,
-        }
-        impl DATA0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - DATA3"]
-            #[inline]
-            pub fn data3(&self) -> DATA3R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA3R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA2"]
-            #[inline]
-            pub fn data2(&self) -> DATA2R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA2R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA1"]
-            #[inline]
-            pub fn data1(&self) -> DATA1R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA1R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA0"]
-            #[inline]
-            pub fn data0(&self) -> DATA0R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA0R { bits }
-            }
-        }
-        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 24:31 - DATA3"]
-            #[inline]
-            pub fn data3(&mut self) -> _DATA3W {
-                _DATA3W { w: self }
-            }
-            #[doc = "Bits 16:23 - DATA2"]
-            #[inline]
-            pub fn data2(&mut self) -> _DATA2W {
-                _DATA2W { w: self }
-            }
-            #[doc = "Bits 8:15 - DATA1"]
-            #[inline]
-            pub fn data1(&mut self) -> _DATA1W {
-                _DATA1W { w: self }
-            }
-            #[doc = "Bits 0:7 - DATA0"]
-            #[inline]
-            pub fn data0(&mut self) -> _DATA0W {
-                _DATA0W { w: self }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct TDH2R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod tdh2r {
-        #[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::TDH2R {
-            #[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 = r" Value of the field"]
-        pub struct DATA7R {
-            bits: u8,
-        }
-        impl DATA7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA6R {
-            bits: u8,
-        }
-        impl DATA6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA5R {
-            bits: u8,
-        }
-        impl DATA5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA4R {
-            bits: u8,
-        }
-        impl DATA4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA6W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA5W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATA4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATA4W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - DATA7"]
-            #[inline]
-            pub fn data7(&self) -> DATA7R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA7R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA6"]
-            #[inline]
-            pub fn data6(&self) -> DATA6R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA6R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA5"]
-            #[inline]
-            pub fn data5(&self) -> DATA5R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA5R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA4"]
-            #[inline]
-            pub fn data4(&self) -> DATA4R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA4R { bits }
-            }
-        }
-        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 24:31 - DATA7"]
-            #[inline]
-            pub fn data7(&mut self) -> _DATA7W {
-                _DATA7W { w: self }
-            }
-            #[doc = "Bits 16:23 - DATA6"]
-            #[inline]
-            pub fn data6(&mut self) -> _DATA6W {
-                _DATA6W { w: self }
-            }
-            #[doc = "Bits 8:15 - DATA5"]
-            #[inline]
-            pub fn data5(&mut self) -> _DATA5W {
-                _DATA5W { w: self }
-            }
-            #[doc = "Bits 0:7 - DATA4"]
-            #[inline]
-            pub fn data4(&mut self) -> _DATA4W {
-                _DATA4W { w: self }
-            }
-        }
-    }
-    #[doc = "receive FIFO mailbox identifier register"]
-    pub struct RI0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "receive FIFO mailbox identifier register"]
-    pub mod ri0r {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RI0R {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STIDR {
-            bits: u16,
-        }
-        impl STIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXIDR {
-            bits: u32,
-        }
-        impl EXIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IDER {
-            bits: bool,
-        }
-        impl IDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTRR {
-            bits: bool,
-        }
-        impl RTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 21:31 - STID"]
-            #[inline]
-            pub fn stid(&self) -> STIDR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                STIDR { bits }
-            }
-            #[doc = "Bits 3:20 - EXID"]
-            #[inline]
-            pub fn exid(&self) -> EXIDR {
-                let bits = {
-                    const MASK: u32 = 0x0003_ffff;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXIDR { bits }
-            }
-            #[doc = "Bit 2 - IDE"]
-            #[inline]
-            pub fn ide(&self) -> IDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDER { bits }
-            }
-            #[doc = "Bit 1 - RTR"]
-            #[inline]
-            pub fn rtr(&self) -> RTRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTRR { bits }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct RDT0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod rdt0r {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RDT0R {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TIMER {
-            bits: u16,
-        }
-        impl TIMER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FMIR {
-            bits: u8,
-        }
-        impl FMIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DLCR {
-            bits: u8,
-        }
-        impl DLCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:31 - TIME"]
-            #[inline]
-            pub fn time(&self) -> TIMER {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TIMER { bits }
-            }
-            #[doc = "Bits 8:15 - FMI"]
-            #[inline]
-            pub fn fmi(&self) -> FMIR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FMIR { bits }
-            }
-            #[doc = "Bits 0:3 - DLC"]
-            #[inline]
-            pub fn dlc(&self) -> DLCR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DLCR { bits }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct RDL0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod rdl0r {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RDL0R {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA3R {
-            bits: u8,
-        }
-        impl DATA3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA2R {
-            bits: u8,
-        }
-        impl DATA2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA1R {
-            bits: u8,
-        }
-        impl DATA1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA0R {
-            bits: u8,
-        }
-        impl DATA0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - DATA3"]
-            #[inline]
-            pub fn data3(&self) -> DATA3R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA3R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA2"]
-            #[inline]
-            pub fn data2(&self) -> DATA2R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA2R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA1"]
-            #[inline]
-            pub fn data1(&self) -> DATA1R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA1R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA0"]
-            #[inline]
-            pub fn data0(&self) -> DATA0R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA0R { bits }
-            }
-        }
-    }
-    #[doc = "receive FIFO mailbox data high register"]
-    pub struct RDH0R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "receive FIFO mailbox data high register"]
-    pub mod rdh0r {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RDH0R {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA7R {
-            bits: u8,
-        }
-        impl DATA7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA6R {
-            bits: u8,
-        }
-        impl DATA6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA5R {
-            bits: u8,
-        }
-        impl DATA5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA4R {
-            bits: u8,
-        }
-        impl DATA4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - DATA7"]
-            #[inline]
-            pub fn data7(&self) -> DATA7R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA7R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA6"]
-            #[inline]
-            pub fn data6(&self) -> DATA6R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA6R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA5"]
-            #[inline]
-            pub fn data5(&self) -> DATA5R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA5R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA4"]
-            #[inline]
-            pub fn data4(&self) -> DATA4R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA4R { bits }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct RI1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod ri1r {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RI1R {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STIDR {
-            bits: u16,
-        }
-        impl STIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EXIDR {
-            bits: u32,
-        }
-        impl EXIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IDER {
-            bits: bool,
-        }
-        impl IDER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RTRR {
-            bits: bool,
-        }
-        impl RTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 21:31 - STID"]
-            #[inline]
-            pub fn stid(&self) -> STIDR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                STIDR { bits }
-            }
-            #[doc = "Bits 3:20 - EXID"]
-            #[inline]
-            pub fn exid(&self) -> EXIDR {
-                let bits = {
-                    const MASK: u32 = 0x0003_ffff;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                EXIDR { bits }
-            }
-            #[doc = "Bit 2 - IDE"]
-            #[inline]
-            pub fn ide(&self) -> IDER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IDER { bits }
-            }
-            #[doc = "Bit 1 - RTR"]
-            #[inline]
-            pub fn rtr(&self) -> RTRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RTRR { bits }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct RDT1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod rdt1r {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RDT1R {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TIMER {
-            bits: u16,
-        }
-        impl TIMER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FMIR {
-            bits: u8,
-        }
-        impl FMIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DLCR {
-            bits: u8,
-        }
-        impl DLCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:31 - TIME"]
-            #[inline]
-            pub fn time(&self) -> TIMER {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TIMER { bits }
-            }
-            #[doc = "Bits 8:15 - FMI"]
-            #[inline]
-            pub fn fmi(&self) -> FMIR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FMIR { bits }
-            }
-            #[doc = "Bits 0:3 - DLC"]
-            #[inline]
-            pub fn dlc(&self) -> DLCR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DLCR { bits }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct RDL1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod rdl1r {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RDL1R {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA3R {
-            bits: u8,
-        }
-        impl DATA3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA2R {
-            bits: u8,
-        }
-        impl DATA2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA1R {
-            bits: u8,
-        }
-        impl DATA1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA0R {
-            bits: u8,
-        }
-        impl DATA0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - DATA3"]
-            #[inline]
-            pub fn data3(&self) -> DATA3R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA3R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA2"]
-            #[inline]
-            pub fn data2(&self) -> DATA2R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA2R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA1"]
-            #[inline]
-            pub fn data1(&self) -> DATA1R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA1R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA0"]
-            #[inline]
-            pub fn data0(&self) -> DATA0R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA0R { bits }
-            }
-        }
-    }
-    #[doc = "mailbox data high register"]
-    pub struct RDH1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "mailbox data high register"]
-    pub mod rdh1r {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RDH1R {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA7R {
-            bits: u8,
-        }
-        impl DATA7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA6R {
-            bits: u8,
-        }
-        impl DATA6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA5R {
-            bits: u8,
-        }
-        impl DATA5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATA4R {
-            bits: u8,
-        }
-        impl DATA4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - DATA7"]
-            #[inline]
-            pub fn data7(&self) -> DATA7R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA7R { bits }
-            }
-            #[doc = "Bits 16:23 - DATA6"]
-            #[inline]
-            pub fn data6(&self) -> DATA6R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA6R { bits }
-            }
-            #[doc = "Bits 8:15 - DATA5"]
-            #[inline]
-            pub fn data5(&self) -> DATA5R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA5R { bits }
-            }
-            #[doc = "Bits 0:7 - DATA4"]
-            #[inline]
-            pub fn data4(&self) -> DATA4R {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATA4R { bits }
-            }
-        }
-    }
-    #[doc = "filter master register"]
-    pub struct FMR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter master register"]
-    pub mod fmr {
-        #[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::FMR {
-            #[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 = r" Value of the field"]
-        pub struct CAN2SBR {
-            bits: u8,
-        }
-        impl CAN2SBR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FINITR {
-            bits: bool,
-        }
-        impl FINITR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CAN2SBW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAN2SBW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x3f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FINITW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FINITW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:13 - CAN2SB"]
-            #[inline]
-            pub fn can2sb(&self) -> CAN2SBR {
-                let bits = {
-                    const MASK: u8 = 0x3f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CAN2SBR { bits }
-            }
-            #[doc = "Bit 0 - FINIT"]
-            #[inline]
-            pub fn finit(&self) -> FINITR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FINITR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x2a1c_0e01 }
-            }
-            #[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 8:13 - CAN2SB"]
-            #[inline]
-            pub fn can2sb(&mut self) -> _CAN2SBW {
-                _CAN2SBW { w: self }
-            }
-            #[doc = "Bit 0 - FINIT"]
-            #[inline]
-            pub fn finit(&mut self) -> _FINITW {
-                _FINITW { w: self }
-            }
-        }
-    }
-    #[doc = "filter mode register"]
-    pub struct FM1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter mode register"]
-    pub mod fm1r {
-        #[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::FM1R {
-            #[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 = r" Value of the field"]
-        pub struct FBM0R {
-            bits: bool,
-        }
-        impl FBM0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM1R {
-            bits: bool,
-        }
-        impl FBM1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM2R {
-            bits: bool,
-        }
-        impl FBM2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM3R {
-            bits: bool,
-        }
-        impl FBM3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM4R {
-            bits: bool,
-        }
-        impl FBM4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM5R {
-            bits: bool,
-        }
-        impl FBM5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM6R {
-            bits: bool,
-        }
-        impl FBM6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM7R {
-            bits: bool,
-        }
-        impl FBM7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM8R {
-            bits: bool,
-        }
-        impl FBM8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM9R {
-            bits: bool,
-        }
-        impl FBM9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM10R {
-            bits: bool,
-        }
-        impl FBM10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM11R {
-            bits: bool,
-        }
-        impl FBM11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM12R {
-            bits: bool,
-        }
-        impl FBM12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM13R {
-            bits: bool,
-        }
-        impl FBM13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM14R {
-            bits: bool,
-        }
-        impl FBM14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM15R {
-            bits: bool,
-        }
-        impl FBM15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM16R {
-            bits: bool,
-        }
-        impl FBM16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM17R {
-            bits: bool,
-        }
-        impl FBM17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM18R {
-            bits: bool,
-        }
-        impl FBM18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM19R {
-            bits: bool,
-        }
-        impl FBM19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM20R {
-            bits: bool,
-        }
-        impl FBM20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM21R {
-            bits: bool,
-        }
-        impl FBM21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM22R {
-            bits: bool,
-        }
-        impl FBM22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM23R {
-            bits: bool,
-        }
-        impl FBM23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM24R {
-            bits: bool,
-        }
-        impl FBM24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM25R {
-            bits: bool,
-        }
-        impl FBM25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM26R {
-            bits: bool,
-        }
-        impl FBM26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FBM27R {
-            bits: bool,
-        }
-        impl FBM27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FBM0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FBM27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBM27W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Filter mode"]
-            #[inline]
-            pub fn fbm0(&self) -> FBM0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM0R { bits }
-            }
-            #[doc = "Bit 1 - Filter mode"]
-            #[inline]
-            pub fn fbm1(&self) -> FBM1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM1R { bits }
-            }
-            #[doc = "Bit 2 - Filter mode"]
-            #[inline]
-            pub fn fbm2(&self) -> FBM2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM2R { bits }
-            }
-            #[doc = "Bit 3 - Filter mode"]
-            #[inline]
-            pub fn fbm3(&self) -> FBM3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM3R { bits }
-            }
-            #[doc = "Bit 4 - Filter mode"]
-            #[inline]
-            pub fn fbm4(&self) -> FBM4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM4R { bits }
-            }
-            #[doc = "Bit 5 - Filter mode"]
-            #[inline]
-            pub fn fbm5(&self) -> FBM5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM5R { bits }
-            }
-            #[doc = "Bit 6 - Filter mode"]
-            #[inline]
-            pub fn fbm6(&self) -> FBM6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM6R { bits }
-            }
-            #[doc = "Bit 7 - Filter mode"]
-            #[inline]
-            pub fn fbm7(&self) -> FBM7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM7R { bits }
-            }
-            #[doc = "Bit 8 - Filter mode"]
-            #[inline]
-            pub fn fbm8(&self) -> FBM8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM8R { bits }
-            }
-            #[doc = "Bit 9 - Filter mode"]
-            #[inline]
-            pub fn fbm9(&self) -> FBM9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM9R { bits }
-            }
-            #[doc = "Bit 10 - Filter mode"]
-            #[inline]
-            pub fn fbm10(&self) -> FBM10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM10R { bits }
-            }
-            #[doc = "Bit 11 - Filter mode"]
-            #[inline]
-            pub fn fbm11(&self) -> FBM11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM11R { bits }
-            }
-            #[doc = "Bit 12 - Filter mode"]
-            #[inline]
-            pub fn fbm12(&self) -> FBM12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM12R { bits }
-            }
-            #[doc = "Bit 13 - Filter mode"]
-            #[inline]
-            pub fn fbm13(&self) -> FBM13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM13R { bits }
-            }
-            #[doc = "Bit 14 - Filter mode"]
-            #[inline]
-            pub fn fbm14(&self) -> FBM14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM14R { bits }
-            }
-            #[doc = "Bit 15 - Filter mode"]
-            #[inline]
-            pub fn fbm15(&self) -> FBM15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM15R { bits }
-            }
-            #[doc = "Bit 16 - Filter mode"]
-            #[inline]
-            pub fn fbm16(&self) -> FBM16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM16R { bits }
-            }
-            #[doc = "Bit 17 - Filter mode"]
-            #[inline]
-            pub fn fbm17(&self) -> FBM17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM17R { bits }
-            }
-            #[doc = "Bit 18 - Filter mode"]
-            #[inline]
-            pub fn fbm18(&self) -> FBM18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM18R { bits }
-            }
-            #[doc = "Bit 19 - Filter mode"]
-            #[inline]
-            pub fn fbm19(&self) -> FBM19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM19R { bits }
-            }
-            #[doc = "Bit 20 - Filter mode"]
-            #[inline]
-            pub fn fbm20(&self) -> FBM20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM20R { bits }
-            }
-            #[doc = "Bit 21 - Filter mode"]
-            #[inline]
-            pub fn fbm21(&self) -> FBM21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM21R { bits }
-            }
-            #[doc = "Bit 22 - Filter mode"]
-            #[inline]
-            pub fn fbm22(&self) -> FBM22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM22R { bits }
-            }
-            #[doc = "Bit 23 - Filter mode"]
-            #[inline]
-            pub fn fbm23(&self) -> FBM23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM23R { bits }
-            }
-            #[doc = "Bit 24 - Filter mode"]
-            #[inline]
-            pub fn fbm24(&self) -> FBM24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM24R { bits }
-            }
-            #[doc = "Bit 25 - Filter mode"]
-            #[inline]
-            pub fn fbm25(&self) -> FBM25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM25R { bits }
-            }
-            #[doc = "Bit 26 - Filter mode"]
-            #[inline]
-            pub fn fbm26(&self) -> FBM26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM26R { bits }
-            }
-            #[doc = "Bit 27 - Filter mode"]
-            #[inline]
-            pub fn fbm27(&self) -> FBM27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FBM27R { bits }
-            }
-        }
-        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 - Filter mode"]
-            #[inline]
-            pub fn fbm0(&mut self) -> _FBM0W {
-                _FBM0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter mode"]
-            #[inline]
-            pub fn fbm1(&mut self) -> _FBM1W {
-                _FBM1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter mode"]
-            #[inline]
-            pub fn fbm2(&mut self) -> _FBM2W {
-                _FBM2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter mode"]
-            #[inline]
-            pub fn fbm3(&mut self) -> _FBM3W {
-                _FBM3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter mode"]
-            #[inline]
-            pub fn fbm4(&mut self) -> _FBM4W {
-                _FBM4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter mode"]
-            #[inline]
-            pub fn fbm5(&mut self) -> _FBM5W {
-                _FBM5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter mode"]
-            #[inline]
-            pub fn fbm6(&mut self) -> _FBM6W {
-                _FBM6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter mode"]
-            #[inline]
-            pub fn fbm7(&mut self) -> _FBM7W {
-                _FBM7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter mode"]
-            #[inline]
-            pub fn fbm8(&mut self) -> _FBM8W {
-                _FBM8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter mode"]
-            #[inline]
-            pub fn fbm9(&mut self) -> _FBM9W {
-                _FBM9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter mode"]
-            #[inline]
-            pub fn fbm10(&mut self) -> _FBM10W {
-                _FBM10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter mode"]
-            #[inline]
-            pub fn fbm11(&mut self) -> _FBM11W {
-                _FBM11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter mode"]
-            #[inline]
-            pub fn fbm12(&mut self) -> _FBM12W {
-                _FBM12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter mode"]
-            #[inline]
-            pub fn fbm13(&mut self) -> _FBM13W {
-                _FBM13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter mode"]
-            #[inline]
-            pub fn fbm14(&mut self) -> _FBM14W {
-                _FBM14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter mode"]
-            #[inline]
-            pub fn fbm15(&mut self) -> _FBM15W {
-                _FBM15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter mode"]
-            #[inline]
-            pub fn fbm16(&mut self) -> _FBM16W {
-                _FBM16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter mode"]
-            #[inline]
-            pub fn fbm17(&mut self) -> _FBM17W {
-                _FBM17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter mode"]
-            #[inline]
-            pub fn fbm18(&mut self) -> _FBM18W {
-                _FBM18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter mode"]
-            #[inline]
-            pub fn fbm19(&mut self) -> _FBM19W {
-                _FBM19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter mode"]
-            #[inline]
-            pub fn fbm20(&mut self) -> _FBM20W {
-                _FBM20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter mode"]
-            #[inline]
-            pub fn fbm21(&mut self) -> _FBM21W {
-                _FBM21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter mode"]
-            #[inline]
-            pub fn fbm22(&mut self) -> _FBM22W {
-                _FBM22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter mode"]
-            #[inline]
-            pub fn fbm23(&mut self) -> _FBM23W {
-                _FBM23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter mode"]
-            #[inline]
-            pub fn fbm24(&mut self) -> _FBM24W {
-                _FBM24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter mode"]
-            #[inline]
-            pub fn fbm25(&mut self) -> _FBM25W {
-                _FBM25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter mode"]
-            #[inline]
-            pub fn fbm26(&mut self) -> _FBM26W {
-                _FBM26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter mode"]
-            #[inline]
-            pub fn fbm27(&mut self) -> _FBM27W {
-                _FBM27W { w: self }
-            }
-        }
-    }
-    #[doc = "filter scale register"]
-    pub struct FS1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter scale register"]
-    pub mod fs1r {
-        #[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::FS1R {
-            #[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 = r" Value of the field"]
-        pub struct FSC0R {
-            bits: bool,
-        }
-        impl FSC0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC1R {
-            bits: bool,
-        }
-        impl FSC1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC2R {
-            bits: bool,
-        }
-        impl FSC2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC3R {
-            bits: bool,
-        }
-        impl FSC3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC4R {
-            bits: bool,
-        }
-        impl FSC4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC5R {
-            bits: bool,
-        }
-        impl FSC5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC6R {
-            bits: bool,
-        }
-        impl FSC6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC7R {
-            bits: bool,
-        }
-        impl FSC7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC8R {
-            bits: bool,
-        }
-        impl FSC8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC9R {
-            bits: bool,
-        }
-        impl FSC9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC10R {
-            bits: bool,
-        }
-        impl FSC10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC11R {
-            bits: bool,
-        }
-        impl FSC11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC12R {
-            bits: bool,
-        }
-        impl FSC12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC13R {
-            bits: bool,
-        }
-        impl FSC13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC14R {
-            bits: bool,
-        }
-        impl FSC14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC15R {
-            bits: bool,
-        }
-        impl FSC15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC16R {
-            bits: bool,
-        }
-        impl FSC16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC17R {
-            bits: bool,
-        }
-        impl FSC17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC18R {
-            bits: bool,
-        }
-        impl FSC18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC19R {
-            bits: bool,
-        }
-        impl FSC19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC20R {
-            bits: bool,
-        }
-        impl FSC20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC21R {
-            bits: bool,
-        }
-        impl FSC21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC22R {
-            bits: bool,
-        }
-        impl FSC22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC23R {
-            bits: bool,
-        }
-        impl FSC23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC24R {
-            bits: bool,
-        }
-        impl FSC24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC25R {
-            bits: bool,
-        }
-        impl FSC25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC26R {
-            bits: bool,
-        }
-        impl FSC26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSC27R {
-            bits: bool,
-        }
-        impl FSC27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FSC0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSC27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSC27W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc0(&self) -> FSC0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC0R { bits }
-            }
-            #[doc = "Bit 1 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc1(&self) -> FSC1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC1R { bits }
-            }
-            #[doc = "Bit 2 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc2(&self) -> FSC2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC2R { bits }
-            }
-            #[doc = "Bit 3 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc3(&self) -> FSC3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC3R { bits }
-            }
-            #[doc = "Bit 4 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc4(&self) -> FSC4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC4R { bits }
-            }
-            #[doc = "Bit 5 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc5(&self) -> FSC5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC5R { bits }
-            }
-            #[doc = "Bit 6 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc6(&self) -> FSC6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC6R { bits }
-            }
-            #[doc = "Bit 7 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc7(&self) -> FSC7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC7R { bits }
-            }
-            #[doc = "Bit 8 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc8(&self) -> FSC8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC8R { bits }
-            }
-            #[doc = "Bit 9 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc9(&self) -> FSC9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC9R { bits }
-            }
-            #[doc = "Bit 10 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc10(&self) -> FSC10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC10R { bits }
-            }
-            #[doc = "Bit 11 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc11(&self) -> FSC11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC11R { bits }
-            }
-            #[doc = "Bit 12 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc12(&self) -> FSC12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC12R { bits }
-            }
-            #[doc = "Bit 13 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc13(&self) -> FSC13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC13R { bits }
-            }
-            #[doc = "Bit 14 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc14(&self) -> FSC14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC14R { bits }
-            }
-            #[doc = "Bit 15 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc15(&self) -> FSC15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC15R { bits }
-            }
-            #[doc = "Bit 16 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc16(&self) -> FSC16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC16R { bits }
-            }
-            #[doc = "Bit 17 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc17(&self) -> FSC17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC17R { bits }
-            }
-            #[doc = "Bit 18 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc18(&self) -> FSC18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC18R { bits }
-            }
-            #[doc = "Bit 19 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc19(&self) -> FSC19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC19R { bits }
-            }
-            #[doc = "Bit 20 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc20(&self) -> FSC20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC20R { bits }
-            }
-            #[doc = "Bit 21 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc21(&self) -> FSC21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC21R { bits }
-            }
-            #[doc = "Bit 22 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc22(&self) -> FSC22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC22R { bits }
-            }
-            #[doc = "Bit 23 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc23(&self) -> FSC23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC23R { bits }
-            }
-            #[doc = "Bit 24 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc24(&self) -> FSC24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC24R { bits }
-            }
-            #[doc = "Bit 25 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc25(&self) -> FSC25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC25R { bits }
-            }
-            #[doc = "Bit 26 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc26(&self) -> FSC26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC26R { bits }
-            }
-            #[doc = "Bit 27 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc27(&self) -> FSC27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSC27R { bits }
-            }
-        }
-        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 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc0(&mut self) -> _FSC0W {
-                _FSC0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc1(&mut self) -> _FSC1W {
-                _FSC1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc2(&mut self) -> _FSC2W {
-                _FSC2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc3(&mut self) -> _FSC3W {
-                _FSC3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc4(&mut self) -> _FSC4W {
-                _FSC4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc5(&mut self) -> _FSC5W {
-                _FSC5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc6(&mut self) -> _FSC6W {
-                _FSC6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc7(&mut self) -> _FSC7W {
-                _FSC7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc8(&mut self) -> _FSC8W {
-                _FSC8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc9(&mut self) -> _FSC9W {
-                _FSC9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc10(&mut self) -> _FSC10W {
-                _FSC10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc11(&mut self) -> _FSC11W {
-                _FSC11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc12(&mut self) -> _FSC12W {
-                _FSC12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc13(&mut self) -> _FSC13W {
-                _FSC13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc14(&mut self) -> _FSC14W {
-                _FSC14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc15(&mut self) -> _FSC15W {
-                _FSC15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc16(&mut self) -> _FSC16W {
-                _FSC16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc17(&mut self) -> _FSC17W {
-                _FSC17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc18(&mut self) -> _FSC18W {
-                _FSC18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc19(&mut self) -> _FSC19W {
-                _FSC19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc20(&mut self) -> _FSC20W {
-                _FSC20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc21(&mut self) -> _FSC21W {
-                _FSC21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc22(&mut self) -> _FSC22W {
-                _FSC22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc23(&mut self) -> _FSC23W {
-                _FSC23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc24(&mut self) -> _FSC24W {
-                _FSC24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc25(&mut self) -> _FSC25W {
-                _FSC25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc26(&mut self) -> _FSC26W {
-                _FSC26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter scale configuration"]
-            #[inline]
-            pub fn fsc27(&mut self) -> _FSC27W {
-                _FSC27W { w: self }
-            }
-        }
-    }
-    #[doc = "filter FIFO assignment register"]
-    pub struct FFA1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter FIFO assignment register"]
-    pub mod ffa1r {
-        #[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::FFA1R {
-            #[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 = r" Value of the field"]
-        pub struct FFA0R {
-            bits: bool,
-        }
-        impl FFA0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA1R {
-            bits: bool,
-        }
-        impl FFA1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA2R {
-            bits: bool,
-        }
-        impl FFA2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA3R {
-            bits: bool,
-        }
-        impl FFA3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA4R {
-            bits: bool,
-        }
-        impl FFA4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA5R {
-            bits: bool,
-        }
-        impl FFA5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA6R {
-            bits: bool,
-        }
-        impl FFA6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA7R {
-            bits: bool,
-        }
-        impl FFA7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA8R {
-            bits: bool,
-        }
-        impl FFA8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA9R {
-            bits: bool,
-        }
-        impl FFA9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA10R {
-            bits: bool,
-        }
-        impl FFA10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA11R {
-            bits: bool,
-        }
-        impl FFA11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA12R {
-            bits: bool,
-        }
-        impl FFA12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA13R {
-            bits: bool,
-        }
-        impl FFA13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA14R {
-            bits: bool,
-        }
-        impl FFA14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA15R {
-            bits: bool,
-        }
-        impl FFA15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA16R {
-            bits: bool,
-        }
-        impl FFA16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA17R {
-            bits: bool,
-        }
-        impl FFA17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA18R {
-            bits: bool,
-        }
-        impl FFA18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA19R {
-            bits: bool,
-        }
-        impl FFA19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA20R {
-            bits: bool,
-        }
-        impl FFA20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA21R {
-            bits: bool,
-        }
-        impl FFA21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA22R {
-            bits: bool,
-        }
-        impl FFA22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA23R {
-            bits: bool,
-        }
-        impl FFA23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA24R {
-            bits: bool,
-        }
-        impl FFA24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA25R {
-            bits: bool,
-        }
-        impl FFA25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA26R {
-            bits: bool,
-        }
-        impl FFA26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFA27R {
-            bits: bool,
-        }
-        impl FFA27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FFA0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFA27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFA27W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Filter FIFO assignment for filter 0"]
-            #[inline]
-            pub fn ffa0(&self) -> FFA0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA0R { bits }
-            }
-            #[doc = "Bit 1 - Filter FIFO assignment for filter 1"]
-            #[inline]
-            pub fn ffa1(&self) -> FFA1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA1R { bits }
-            }
-            #[doc = "Bit 2 - Filter FIFO assignment for filter 2"]
-            #[inline]
-            pub fn ffa2(&self) -> FFA2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA2R { bits }
-            }
-            #[doc = "Bit 3 - Filter FIFO assignment for filter 3"]
-            #[inline]
-            pub fn ffa3(&self) -> FFA3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA3R { bits }
-            }
-            #[doc = "Bit 4 - Filter FIFO assignment for filter 4"]
-            #[inline]
-            pub fn ffa4(&self) -> FFA4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA4R { bits }
-            }
-            #[doc = "Bit 5 - Filter FIFO assignment for filter 5"]
-            #[inline]
-            pub fn ffa5(&self) -> FFA5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA5R { bits }
-            }
-            #[doc = "Bit 6 - Filter FIFO assignment for filter 6"]
-            #[inline]
-            pub fn ffa6(&self) -> FFA6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA6R { bits }
-            }
-            #[doc = "Bit 7 - Filter FIFO assignment for filter 7"]
-            #[inline]
-            pub fn ffa7(&self) -> FFA7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA7R { bits }
-            }
-            #[doc = "Bit 8 - Filter FIFO assignment for filter 8"]
-            #[inline]
-            pub fn ffa8(&self) -> FFA8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA8R { bits }
-            }
-            #[doc = "Bit 9 - Filter FIFO assignment for filter 9"]
-            #[inline]
-            pub fn ffa9(&self) -> FFA9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA9R { bits }
-            }
-            #[doc = "Bit 10 - Filter FIFO assignment for filter 10"]
-            #[inline]
-            pub fn ffa10(&self) -> FFA10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA10R { bits }
-            }
-            #[doc = "Bit 11 - Filter FIFO assignment for filter 11"]
-            #[inline]
-            pub fn ffa11(&self) -> FFA11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA11R { bits }
-            }
-            #[doc = "Bit 12 - Filter FIFO assignment for filter 12"]
-            #[inline]
-            pub fn ffa12(&self) -> FFA12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA12R { bits }
-            }
-            #[doc = "Bit 13 - Filter FIFO assignment for filter 13"]
-            #[inline]
-            pub fn ffa13(&self) -> FFA13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA13R { bits }
-            }
-            #[doc = "Bit 14 - Filter FIFO assignment for filter 14"]
-            #[inline]
-            pub fn ffa14(&self) -> FFA14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA14R { bits }
-            }
-            #[doc = "Bit 15 - Filter FIFO assignment for filter 15"]
-            #[inline]
-            pub fn ffa15(&self) -> FFA15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA15R { bits }
-            }
-            #[doc = "Bit 16 - Filter FIFO assignment for filter 16"]
-            #[inline]
-            pub fn ffa16(&self) -> FFA16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA16R { bits }
-            }
-            #[doc = "Bit 17 - Filter FIFO assignment for filter 17"]
-            #[inline]
-            pub fn ffa17(&self) -> FFA17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA17R { bits }
-            }
-            #[doc = "Bit 18 - Filter FIFO assignment for filter 18"]
-            #[inline]
-            pub fn ffa18(&self) -> FFA18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA18R { bits }
-            }
-            #[doc = "Bit 19 - Filter FIFO assignment for filter 19"]
-            #[inline]
-            pub fn ffa19(&self) -> FFA19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA19R { bits }
-            }
-            #[doc = "Bit 20 - Filter FIFO assignment for filter 20"]
-            #[inline]
-            pub fn ffa20(&self) -> FFA20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA20R { bits }
-            }
-            #[doc = "Bit 21 - Filter FIFO assignment for filter 21"]
-            #[inline]
-            pub fn ffa21(&self) -> FFA21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA21R { bits }
-            }
-            #[doc = "Bit 22 - Filter FIFO assignment for filter 22"]
-            #[inline]
-            pub fn ffa22(&self) -> FFA22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA22R { bits }
-            }
-            #[doc = "Bit 23 - Filter FIFO assignment for filter 23"]
-            #[inline]
-            pub fn ffa23(&self) -> FFA23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA23R { bits }
-            }
-            #[doc = "Bit 24 - Filter FIFO assignment for filter 24"]
-            #[inline]
-            pub fn ffa24(&self) -> FFA24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA24R { bits }
-            }
-            #[doc = "Bit 25 - Filter FIFO assignment for filter 25"]
-            #[inline]
-            pub fn ffa25(&self) -> FFA25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA25R { bits }
-            }
-            #[doc = "Bit 26 - Filter FIFO assignment for filter 26"]
-            #[inline]
-            pub fn ffa26(&self) -> FFA26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA26R { bits }
-            }
-            #[doc = "Bit 27 - Filter FIFO assignment for filter 27"]
-            #[inline]
-            pub fn ffa27(&self) -> FFA27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFA27R { bits }
-            }
-        }
-        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 - Filter FIFO assignment for filter 0"]
-            #[inline]
-            pub fn ffa0(&mut self) -> _FFA0W {
-                _FFA0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter FIFO assignment for filter 1"]
-            #[inline]
-            pub fn ffa1(&mut self) -> _FFA1W {
-                _FFA1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter FIFO assignment for filter 2"]
-            #[inline]
-            pub fn ffa2(&mut self) -> _FFA2W {
-                _FFA2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter FIFO assignment for filter 3"]
-            #[inline]
-            pub fn ffa3(&mut self) -> _FFA3W {
-                _FFA3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter FIFO assignment for filter 4"]
-            #[inline]
-            pub fn ffa4(&mut self) -> _FFA4W {
-                _FFA4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter FIFO assignment for filter 5"]
-            #[inline]
-            pub fn ffa5(&mut self) -> _FFA5W {
-                _FFA5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter FIFO assignment for filter 6"]
-            #[inline]
-            pub fn ffa6(&mut self) -> _FFA6W {
-                _FFA6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter FIFO assignment for filter 7"]
-            #[inline]
-            pub fn ffa7(&mut self) -> _FFA7W {
-                _FFA7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter FIFO assignment for filter 8"]
-            #[inline]
-            pub fn ffa8(&mut self) -> _FFA8W {
-                _FFA8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter FIFO assignment for filter 9"]
-            #[inline]
-            pub fn ffa9(&mut self) -> _FFA9W {
-                _FFA9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter FIFO assignment for filter 10"]
-            #[inline]
-            pub fn ffa10(&mut self) -> _FFA10W {
-                _FFA10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter FIFO assignment for filter 11"]
-            #[inline]
-            pub fn ffa11(&mut self) -> _FFA11W {
-                _FFA11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter FIFO assignment for filter 12"]
-            #[inline]
-            pub fn ffa12(&mut self) -> _FFA12W {
-                _FFA12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter FIFO assignment for filter 13"]
-            #[inline]
-            pub fn ffa13(&mut self) -> _FFA13W {
-                _FFA13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter FIFO assignment for filter 14"]
-            #[inline]
-            pub fn ffa14(&mut self) -> _FFA14W {
-                _FFA14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter FIFO assignment for filter 15"]
-            #[inline]
-            pub fn ffa15(&mut self) -> _FFA15W {
-                _FFA15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter FIFO assignment for filter 16"]
-            #[inline]
-            pub fn ffa16(&mut self) -> _FFA16W {
-                _FFA16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter FIFO assignment for filter 17"]
-            #[inline]
-            pub fn ffa17(&mut self) -> _FFA17W {
-                _FFA17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter FIFO assignment for filter 18"]
-            #[inline]
-            pub fn ffa18(&mut self) -> _FFA18W {
-                _FFA18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter FIFO assignment for filter 19"]
-            #[inline]
-            pub fn ffa19(&mut self) -> _FFA19W {
-                _FFA19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter FIFO assignment for filter 20"]
-            #[inline]
-            pub fn ffa20(&mut self) -> _FFA20W {
-                _FFA20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter FIFO assignment for filter 21"]
-            #[inline]
-            pub fn ffa21(&mut self) -> _FFA21W {
-                _FFA21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter FIFO assignment for filter 22"]
-            #[inline]
-            pub fn ffa22(&mut self) -> _FFA22W {
-                _FFA22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter FIFO assignment for filter 23"]
-            #[inline]
-            pub fn ffa23(&mut self) -> _FFA23W {
-                _FFA23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter FIFO assignment for filter 24"]
-            #[inline]
-            pub fn ffa24(&mut self) -> _FFA24W {
-                _FFA24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter FIFO assignment for filter 25"]
-            #[inline]
-            pub fn ffa25(&mut self) -> _FFA25W {
-                _FFA25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter FIFO assignment for filter 26"]
-            #[inline]
-            pub fn ffa26(&mut self) -> _FFA26W {
-                _FFA26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter FIFO assignment for filter 27"]
-            #[inline]
-            pub fn ffa27(&mut self) -> _FFA27W {
-                _FFA27W { w: self }
-            }
-        }
-    }
-    #[doc = "filter activation register"]
-    pub struct FA1R {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "filter activation register"]
-    pub mod fa1r {
-        #[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::FA1R {
-            #[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 = r" Value of the field"]
-        pub struct FACT0R {
-            bits: bool,
-        }
-        impl FACT0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT1R {
-            bits: bool,
-        }
-        impl FACT1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT2R {
-            bits: bool,
-        }
-        impl FACT2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT3R {
-            bits: bool,
-        }
-        impl FACT3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT4R {
-            bits: bool,
-        }
-        impl FACT4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT5R {
-            bits: bool,
-        }
-        impl FACT5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT6R {
-            bits: bool,
-        }
-        impl FACT6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT7R {
-            bits: bool,
-        }
-        impl FACT7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT8R {
-            bits: bool,
-        }
-        impl FACT8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT9R {
-            bits: bool,
-        }
-        impl FACT9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT10R {
-            bits: bool,
-        }
-        impl FACT10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT11R {
-            bits: bool,
-        }
-        impl FACT11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT12R {
-            bits: bool,
-        }
-        impl FACT12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT13R {
-            bits: bool,
-        }
-        impl FACT13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT14R {
-            bits: bool,
-        }
-        impl FACT14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT15R {
-            bits: bool,
-        }
-        impl FACT15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT16R {
-            bits: bool,
-        }
-        impl FACT16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT17R {
-            bits: bool,
-        }
-        impl FACT17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT18R {
-            bits: bool,
-        }
-        impl FACT18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT19R {
-            bits: bool,
-        }
-        impl FACT19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT20R {
-            bits: bool,
-        }
-        impl FACT20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT21R {
-            bits: bool,
-        }
-        impl FACT21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT22R {
-            bits: bool,
-        }
-        impl FACT22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT23R {
-            bits: bool,
-        }
-        impl FACT23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT24R {
-            bits: bool,
-        }
-        impl FACT24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT25R {
-            bits: bool,
-        }
-        impl FACT25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT26R {
-            bits: bool,
-        }
-        impl FACT26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACT27R {
-            bits: bool,
-        }
-        impl FACT27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FACT0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACT27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACT27W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Filter active"]
-            #[inline]
-            pub fn fact0(&self) -> FACT0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT0R { bits }
-            }
-            #[doc = "Bit 1 - Filter active"]
-            #[inline]
-            pub fn fact1(&self) -> FACT1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT1R { bits }
-            }
-            #[doc = "Bit 2 - Filter active"]
-            #[inline]
-            pub fn fact2(&self) -> FACT2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT2R { bits }
-            }
-            #[doc = "Bit 3 - Filter active"]
-            #[inline]
-            pub fn fact3(&self) -> FACT3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT3R { bits }
-            }
-            #[doc = "Bit 4 - Filter active"]
-            #[inline]
-            pub fn fact4(&self) -> FACT4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT4R { bits }
-            }
-            #[doc = "Bit 5 - Filter active"]
-            #[inline]
-            pub fn fact5(&self) -> FACT5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT5R { bits }
-            }
-            #[doc = "Bit 6 - Filter active"]
-            #[inline]
-            pub fn fact6(&self) -> FACT6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT6R { bits }
-            }
-            #[doc = "Bit 7 - Filter active"]
-            #[inline]
-            pub fn fact7(&self) -> FACT7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT7R { bits }
-            }
-            #[doc = "Bit 8 - Filter active"]
-            #[inline]
-            pub fn fact8(&self) -> FACT8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT8R { bits }
-            }
-            #[doc = "Bit 9 - Filter active"]
-            #[inline]
-            pub fn fact9(&self) -> FACT9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT9R { bits }
-            }
-            #[doc = "Bit 10 - Filter active"]
-            #[inline]
-            pub fn fact10(&self) -> FACT10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT10R { bits }
-            }
-            #[doc = "Bit 11 - Filter active"]
-            #[inline]
-            pub fn fact11(&self) -> FACT11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT11R { bits }
-            }
-            #[doc = "Bit 12 - Filter active"]
-            #[inline]
-            pub fn fact12(&self) -> FACT12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT12R { bits }
-            }
-            #[doc = "Bit 13 - Filter active"]
-            #[inline]
-            pub fn fact13(&self) -> FACT13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT13R { bits }
-            }
-            #[doc = "Bit 14 - Filter active"]
-            #[inline]
-            pub fn fact14(&self) -> FACT14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT14R { bits }
-            }
-            #[doc = "Bit 15 - Filter active"]
-            #[inline]
-            pub fn fact15(&self) -> FACT15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT15R { bits }
-            }
-            #[doc = "Bit 16 - Filter active"]
-            #[inline]
-            pub fn fact16(&self) -> FACT16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT16R { bits }
-            }
-            #[doc = "Bit 17 - Filter active"]
-            #[inline]
-            pub fn fact17(&self) -> FACT17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT17R { bits }
-            }
-            #[doc = "Bit 18 - Filter active"]
-            #[inline]
-            pub fn fact18(&self) -> FACT18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT18R { bits }
-            }
-            #[doc = "Bit 19 - Filter active"]
-            #[inline]
-            pub fn fact19(&self) -> FACT19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT19R { bits }
-            }
-            #[doc = "Bit 20 - Filter active"]
-            #[inline]
-            pub fn fact20(&self) -> FACT20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT20R { bits }
-            }
-            #[doc = "Bit 21 - Filter active"]
-            #[inline]
-            pub fn fact21(&self) -> FACT21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT21R { bits }
-            }
-            #[doc = "Bit 22 - Filter active"]
-            #[inline]
-            pub fn fact22(&self) -> FACT22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT22R { bits }
-            }
-            #[doc = "Bit 23 - Filter active"]
-            #[inline]
-            pub fn fact23(&self) -> FACT23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT23R { bits }
-            }
-            #[doc = "Bit 24 - Filter active"]
-            #[inline]
-            pub fn fact24(&self) -> FACT24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT24R { bits }
-            }
-            #[doc = "Bit 25 - Filter active"]
-            #[inline]
-            pub fn fact25(&self) -> FACT25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT25R { bits }
-            }
-            #[doc = "Bit 26 - Filter active"]
-            #[inline]
-            pub fn fact26(&self) -> FACT26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT26R { bits }
-            }
-            #[doc = "Bit 27 - Filter active"]
-            #[inline]
-            pub fn fact27(&self) -> FACT27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACT27R { bits }
-            }
-        }
-        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 - Filter active"]
-            #[inline]
-            pub fn fact0(&mut self) -> _FACT0W {
-                _FACT0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter active"]
-            #[inline]
-            pub fn fact1(&mut self) -> _FACT1W {
-                _FACT1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter active"]
-            #[inline]
-            pub fn fact2(&mut self) -> _FACT2W {
-                _FACT2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter active"]
-            #[inline]
-            pub fn fact3(&mut self) -> _FACT3W {
-                _FACT3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter active"]
-            #[inline]
-            pub fn fact4(&mut self) -> _FACT4W {
-                _FACT4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter active"]
-            #[inline]
-            pub fn fact5(&mut self) -> _FACT5W {
-                _FACT5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter active"]
-            #[inline]
-            pub fn fact6(&mut self) -> _FACT6W {
-                _FACT6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter active"]
-            #[inline]
-            pub fn fact7(&mut self) -> _FACT7W {
-                _FACT7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter active"]
-            #[inline]
-            pub fn fact8(&mut self) -> _FACT8W {
-                _FACT8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter active"]
-            #[inline]
-            pub fn fact9(&mut self) -> _FACT9W {
-                _FACT9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter active"]
-            #[inline]
-            pub fn fact10(&mut self) -> _FACT10W {
-                _FACT10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter active"]
-            #[inline]
-            pub fn fact11(&mut self) -> _FACT11W {
-                _FACT11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter active"]
-            #[inline]
-            pub fn fact12(&mut self) -> _FACT12W {
-                _FACT12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter active"]
-            #[inline]
-            pub fn fact13(&mut self) -> _FACT13W {
-                _FACT13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter active"]
-            #[inline]
-            pub fn fact14(&mut self) -> _FACT14W {
-                _FACT14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter active"]
-            #[inline]
-            pub fn fact15(&mut self) -> _FACT15W {
-                _FACT15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter active"]
-            #[inline]
-            pub fn fact16(&mut self) -> _FACT16W {
-                _FACT16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter active"]
-            #[inline]
-            pub fn fact17(&mut self) -> _FACT17W {
-                _FACT17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter active"]
-            #[inline]
-            pub fn fact18(&mut self) -> _FACT18W {
-                _FACT18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter active"]
-            #[inline]
-            pub fn fact19(&mut self) -> _FACT19W {
-                _FACT19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter active"]
-            #[inline]
-            pub fn fact20(&mut self) -> _FACT20W {
-                _FACT20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter active"]
-            #[inline]
-            pub fn fact21(&mut self) -> _FACT21W {
-                _FACT21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter active"]
-            #[inline]
-            pub fn fact22(&mut self) -> _FACT22W {
-                _FACT22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter active"]
-            #[inline]
-            pub fn fact23(&mut self) -> _FACT23W {
-                _FACT23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter active"]
-            #[inline]
-            pub fn fact24(&mut self) -> _FACT24W {
-                _FACT24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter active"]
-            #[inline]
-            pub fn fact25(&mut self) -> _FACT25W {
-                _FACT25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter active"]
-            #[inline]
-            pub fn fact26(&mut self) -> _FACT26W {
-                _FACT26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter active"]
-            #[inline]
-            pub fn fact27(&mut self) -> _FACT27W {
-                _FACT27W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 0 register 1"]
-    pub struct F0R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 0 register 1"]
-    pub mod f0r1 {
-        #[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::F0R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 0 register 2"]
-    pub struct F0R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 0 register 2"]
-    pub mod f0r2 {
-        #[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::F0R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 1 register 1"]
-    pub struct F1R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 1 register 1"]
-    pub mod f1r1 {
-        #[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::F1R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 1 register 2"]
-    pub struct F1R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 1 register 2"]
-    pub mod f1r2 {
-        #[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::F1R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 2 register 1"]
-    pub struct F2R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 2 register 1"]
-    pub mod f2r1 {
-        #[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::F2R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 2 register 2"]
-    pub struct F2R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 2 register 2"]
-    pub mod f2r2 {
-        #[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::F2R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 3 register 1"]
-    pub struct F3R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 3 register 1"]
-    pub mod f3r1 {
-        #[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::F3R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 3 register 2"]
-    pub struct F3R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 3 register 2"]
-    pub mod f3r2 {
-        #[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::F3R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 4 register 1"]
-    pub struct F4R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 4 register 1"]
-    pub mod f4r1 {
-        #[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::F4R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 4 register 2"]
-    pub struct F4R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 4 register 2"]
-    pub mod f4r2 {
-        #[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::F4R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 5 register 1"]
-    pub struct F5R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 5 register 1"]
-    pub mod f5r1 {
-        #[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::F5R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 5 register 2"]
-    pub struct F5R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 5 register 2"]
-    pub mod f5r2 {
-        #[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::F5R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 6 register 1"]
-    pub struct F6R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 6 register 1"]
-    pub mod f6r1 {
-        #[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::F6R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 6 register 2"]
-    pub struct F6R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 6 register 2"]
-    pub mod f6r2 {
-        #[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::F6R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 7 register 1"]
-    pub struct F7R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 7 register 1"]
-    pub mod f7r1 {
-        #[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::F7R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 7 register 2"]
-    pub struct F7R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 7 register 2"]
-    pub mod f7r2 {
-        #[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::F7R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 8 register 1"]
-    pub struct F8R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 8 register 1"]
-    pub mod f8r1 {
-        #[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::F8R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 8 register 2"]
-    pub struct F8R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 8 register 2"]
-    pub mod f8r2 {
-        #[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::F8R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 9 register 1"]
-    pub struct F9R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 9 register 1"]
-    pub mod f9r1 {
-        #[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::F9R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 9 register 2"]
-    pub struct F9R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 9 register 2"]
-    pub mod f9r2 {
-        #[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::F9R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 10 register 1"]
-    pub struct F10R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 10 register 1"]
-    pub mod f10r1 {
-        #[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::F10R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 10 register 2"]
-    pub struct F10R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 10 register 2"]
-    pub mod f10r2 {
-        #[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::F10R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 11 register 1"]
-    pub struct F11R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 11 register 1"]
-    pub mod f11r1 {
-        #[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::F11R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 11 register 2"]
-    pub struct F11R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 11 register 2"]
-    pub mod f11r2 {
-        #[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::F11R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 4 register 1"]
-    pub struct F12R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 4 register 1"]
-    pub mod f12r1 {
-        #[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::F12R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 12 register 2"]
-    pub struct F12R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 12 register 2"]
-    pub mod f12r2 {
-        #[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::F12R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 13 register 1"]
-    pub struct F13R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 13 register 1"]
-    pub mod f13r1 {
-        #[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::F13R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 13 register 2"]
-    pub struct F13R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 13 register 2"]
-    pub mod f13r2 {
-        #[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::F13R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 14 register 1"]
-    pub struct F14R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 14 register 1"]
-    pub mod f14r1 {
-        #[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::F14R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 14 register 2"]
-    pub struct F14R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 14 register 2"]
-    pub mod f14r2 {
-        #[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::F14R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 15 register 1"]
-    pub struct F15R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 15 register 1"]
-    pub mod f15r1 {
-        #[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::F15R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 15 register 2"]
-    pub struct F15R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 15 register 2"]
-    pub mod f15r2 {
-        #[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::F15R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 16 register 1"]
-    pub struct F16R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 16 register 1"]
-    pub mod f16r1 {
-        #[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::F16R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 16 register 2"]
-    pub struct F16R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 16 register 2"]
-    pub mod f16r2 {
-        #[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::F16R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 17 register 1"]
-    pub struct F17R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 17 register 1"]
-    pub mod f17r1 {
-        #[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::F17R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 17 register 2"]
-    pub struct F17R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 17 register 2"]
-    pub mod f17r2 {
-        #[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::F17R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 18 register 1"]
-    pub struct F18R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 18 register 1"]
-    pub mod f18r1 {
-        #[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::F18R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 18 register 2"]
-    pub struct F18R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 18 register 2"]
-    pub mod f18r2 {
-        #[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::F18R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 19 register 1"]
-    pub struct F19R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 19 register 1"]
-    pub mod f19r1 {
-        #[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::F19R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 19 register 2"]
-    pub struct F19R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 19 register 2"]
-    pub mod f19r2 {
-        #[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::F19R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 20 register 1"]
-    pub struct F20R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 20 register 1"]
-    pub mod f20r1 {
-        #[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::F20R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 20 register 2"]
-    pub struct F20R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 20 register 2"]
-    pub mod f20r2 {
-        #[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::F20R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 21 register 1"]
-    pub struct F21R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 21 register 1"]
-    pub mod f21r1 {
-        #[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::F21R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 21 register 2"]
-    pub struct F21R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 21 register 2"]
-    pub mod f21r2 {
-        #[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::F21R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 22 register 1"]
-    pub struct F22R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 22 register 1"]
-    pub mod f22r1 {
-        #[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::F22R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 22 register 2"]
-    pub struct F22R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 22 register 2"]
-    pub mod f22r2 {
-        #[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::F22R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 23 register 1"]
-    pub struct F23R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 23 register 1"]
-    pub mod f23r1 {
-        #[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::F23R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 23 register 2"]
-    pub struct F23R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 23 register 2"]
-    pub mod f23r2 {
-        #[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::F23R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 24 register 1"]
-    pub struct F24R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 24 register 1"]
-    pub mod f24r1 {
-        #[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::F24R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 24 register 2"]
-    pub struct F24R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 24 register 2"]
-    pub mod f24r2 {
-        #[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::F24R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 25 register 1"]
-    pub struct F25R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 25 register 1"]
-    pub mod f25r1 {
-        #[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::F25R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 25 register 2"]
-    pub struct F25R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 25 register 2"]
-    pub mod f25r2 {
-        #[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::F25R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 26 register 1"]
-    pub struct F26R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 26 register 1"]
-    pub mod f26r1 {
-        #[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::F26R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 26 register 2"]
-    pub struct F26R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 26 register 2"]
-    pub mod f26r2 {
-        #[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::F26R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 27 register 1"]
-    pub struct F27R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 27 register 1"]
-    pub mod f27r1 {
-        #[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::F27R1 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-    #[doc = "Filter bank 27 register 2"]
-    pub struct F27R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Filter bank 27 register 2"]
-    pub mod f27r2 {
-        #[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::F27R2 {
-            #[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 = r" Value of the field"]
-        pub struct FB0R {
-            bits: bool,
-        }
-        impl FB0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB1R {
-            bits: bool,
-        }
-        impl FB1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB2R {
-            bits: bool,
-        }
-        impl FB2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB3R {
-            bits: bool,
-        }
-        impl FB3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB4R {
-            bits: bool,
-        }
-        impl FB4R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB5R {
-            bits: bool,
-        }
-        impl FB5R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB6R {
-            bits: bool,
-        }
-        impl FB6R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB7R {
-            bits: bool,
-        }
-        impl FB7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB8R {
-            bits: bool,
-        }
-        impl FB8R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB9R {
-            bits: bool,
-        }
-        impl FB9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB10R {
-            bits: bool,
-        }
-        impl FB10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB11R {
-            bits: bool,
-        }
-        impl FB11R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB12R {
-            bits: bool,
-        }
-        impl FB12R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB13R {
-            bits: bool,
-        }
-        impl FB13R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB14R {
-            bits: bool,
-        }
-        impl FB14R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB15R {
-            bits: bool,
-        }
-        impl FB15R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB16R {
-            bits: bool,
-        }
-        impl FB16R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB17R {
-            bits: bool,
-        }
-        impl FB17R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB18R {
-            bits: bool,
-        }
-        impl FB18R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB19R {
-            bits: bool,
-        }
-        impl FB19R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB20R {
-            bits: bool,
-        }
-        impl FB20R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB21R {
-            bits: bool,
-        }
-        impl FB21R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB22R {
-            bits: bool,
-        }
-        impl FB22R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB23R {
-            bits: bool,
-        }
-        impl FB23R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB24R {
-            bits: bool,
-        }
-        impl FB24R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB25R {
-            bits: bool,
-        }
-        impl FB25R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB26R {
-            bits: bool,
-        }
-        impl FB26R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB27R {
-            bits: bool,
-        }
-        impl FB27R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB28R {
-            bits: bool,
-        }
-        impl FB28R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB29R {
-            bits: bool,
-        }
-        impl FB29R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB30R {
-            bits: bool,
-        }
-        impl FB30R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FB31R {
-            bits: bool,
-        }
-        impl FB31R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FB0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB3W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB4W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB4W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB5W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB5W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB6W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB6W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB7W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB8W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB8W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB9W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB11W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB11W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB12W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB12W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB13W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB13W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB14W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB14W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB15W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB15W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB16W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB16W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB17W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB17W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB18W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB18W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB19W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB19W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB20W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB20W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB21W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB21W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB22W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB22W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB23W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB23W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB24W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB24W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB25W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB25W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB26W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB26W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB27W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB27W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB28W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB28W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB29W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB29W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB30W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB30W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FB31W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FB31W<'a> {
-            #[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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&self) -> FB0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB0R { bits }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&self) -> FB1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB1R { bits }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&self) -> FB2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB2R { bits }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&self) -> FB3R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB3R { bits }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&self) -> FB4R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB4R { bits }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&self) -> FB5R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB5R { bits }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&self) -> FB6R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB6R { bits }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&self) -> FB7R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB7R { bits }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&self) -> FB8R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB8R { bits }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&self) -> FB9R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB9R { bits }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&self) -> FB10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB10R { bits }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&self) -> FB11R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB11R { bits }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&self) -> FB12R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB12R { bits }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&self) -> FB13R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB13R { bits }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&self) -> FB14R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB14R { bits }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&self) -> FB15R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB15R { bits }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&self) -> FB16R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB16R { bits }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&self) -> FB17R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB17R { bits }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&self) -> FB18R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB18R { bits }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&self) -> FB19R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB19R { bits }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&self) -> FB20R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB20R { bits }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&self) -> FB21R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB21R { bits }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&self) -> FB22R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB22R { bits }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&self) -> FB23R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB23R { bits }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&self) -> FB24R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB24R { bits }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&self) -> FB25R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB25R { bits }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&self) -> FB26R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB26R { bits }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&self) -> FB27R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 27;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB27R { bits }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&self) -> FB28R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB28R { bits }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&self) -> FB29R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB29R { bits }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&self) -> FB30R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB30R { bits }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&self) -> FB31R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FB31R { bits }
-            }
-        }
-        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 - Filter bits"]
-            #[inline]
-            pub fn fb0(&mut self) -> _FB0W {
-                _FB0W { w: self }
-            }
-            #[doc = "Bit 1 - Filter bits"]
-            #[inline]
-            pub fn fb1(&mut self) -> _FB1W {
-                _FB1W { w: self }
-            }
-            #[doc = "Bit 2 - Filter bits"]
-            #[inline]
-            pub fn fb2(&mut self) -> _FB2W {
-                _FB2W { w: self }
-            }
-            #[doc = "Bit 3 - Filter bits"]
-            #[inline]
-            pub fn fb3(&mut self) -> _FB3W {
-                _FB3W { w: self }
-            }
-            #[doc = "Bit 4 - Filter bits"]
-            #[inline]
-            pub fn fb4(&mut self) -> _FB4W {
-                _FB4W { w: self }
-            }
-            #[doc = "Bit 5 - Filter bits"]
-            #[inline]
-            pub fn fb5(&mut self) -> _FB5W {
-                _FB5W { w: self }
-            }
-            #[doc = "Bit 6 - Filter bits"]
-            #[inline]
-            pub fn fb6(&mut self) -> _FB6W {
-                _FB6W { w: self }
-            }
-            #[doc = "Bit 7 - Filter bits"]
-            #[inline]
-            pub fn fb7(&mut self) -> _FB7W {
-                _FB7W { w: self }
-            }
-            #[doc = "Bit 8 - Filter bits"]
-            #[inline]
-            pub fn fb8(&mut self) -> _FB8W {
-                _FB8W { w: self }
-            }
-            #[doc = "Bit 9 - Filter bits"]
-            #[inline]
-            pub fn fb9(&mut self) -> _FB9W {
-                _FB9W { w: self }
-            }
-            #[doc = "Bit 10 - Filter bits"]
-            #[inline]
-            pub fn fb10(&mut self) -> _FB10W {
-                _FB10W { w: self }
-            }
-            #[doc = "Bit 11 - Filter bits"]
-            #[inline]
-            pub fn fb11(&mut self) -> _FB11W {
-                _FB11W { w: self }
-            }
-            #[doc = "Bit 12 - Filter bits"]
-            #[inline]
-            pub fn fb12(&mut self) -> _FB12W {
-                _FB12W { w: self }
-            }
-            #[doc = "Bit 13 - Filter bits"]
-            #[inline]
-            pub fn fb13(&mut self) -> _FB13W {
-                _FB13W { w: self }
-            }
-            #[doc = "Bit 14 - Filter bits"]
-            #[inline]
-            pub fn fb14(&mut self) -> _FB14W {
-                _FB14W { w: self }
-            }
-            #[doc = "Bit 15 - Filter bits"]
-            #[inline]
-            pub fn fb15(&mut self) -> _FB15W {
-                _FB15W { w: self }
-            }
-            #[doc = "Bit 16 - Filter bits"]
-            #[inline]
-            pub fn fb16(&mut self) -> _FB16W {
-                _FB16W { w: self }
-            }
-            #[doc = "Bit 17 - Filter bits"]
-            #[inline]
-            pub fn fb17(&mut self) -> _FB17W {
-                _FB17W { w: self }
-            }
-            #[doc = "Bit 18 - Filter bits"]
-            #[inline]
-            pub fn fb18(&mut self) -> _FB18W {
-                _FB18W { w: self }
-            }
-            #[doc = "Bit 19 - Filter bits"]
-            #[inline]
-            pub fn fb19(&mut self) -> _FB19W {
-                _FB19W { w: self }
-            }
-            #[doc = "Bit 20 - Filter bits"]
-            #[inline]
-            pub fn fb20(&mut self) -> _FB20W {
-                _FB20W { w: self }
-            }
-            #[doc = "Bit 21 - Filter bits"]
-            #[inline]
-            pub fn fb21(&mut self) -> _FB21W {
-                _FB21W { w: self }
-            }
-            #[doc = "Bit 22 - Filter bits"]
-            #[inline]
-            pub fn fb22(&mut self) -> _FB22W {
-                _FB22W { w: self }
-            }
-            #[doc = "Bit 23 - Filter bits"]
-            #[inline]
-            pub fn fb23(&mut self) -> _FB23W {
-                _FB23W { w: self }
-            }
-            #[doc = "Bit 24 - Filter bits"]
-            #[inline]
-            pub fn fb24(&mut self) -> _FB24W {
-                _FB24W { w: self }
-            }
-            #[doc = "Bit 25 - Filter bits"]
-            #[inline]
-            pub fn fb25(&mut self) -> _FB25W {
-                _FB25W { w: self }
-            }
-            #[doc = "Bit 26 - Filter bits"]
-            #[inline]
-            pub fn fb26(&mut self) -> _FB26W {
-                _FB26W { w: self }
-            }
-            #[doc = "Bit 27 - Filter bits"]
-            #[inline]
-            pub fn fb27(&mut self) -> _FB27W {
-                _FB27W { w: self }
-            }
-            #[doc = "Bit 28 - Filter bits"]
-            #[inline]
-            pub fn fb28(&mut self) -> _FB28W {
-                _FB28W { w: self }
-            }
-            #[doc = "Bit 29 - Filter bits"]
-            #[inline]
-            pub fn fb29(&mut self) -> _FB29W {
-                _FB29W { w: self }
-            }
-            #[doc = "Bit 30 - Filter bits"]
-            #[inline]
-            pub fn fb30(&mut self) -> _FB30W {
-                _FB30W { w: self }
-            }
-            #[doc = "Bit 31 - Filter bits"]
-            #[inline]
-            pub fn fb31(&mut self) -> _FB31W {
-                _FB31W { w: self }
-            }
-        }
-    }
-}
-#[doc = "CAN2"]
-pub struct CAN2 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for CAN2 {}
-impl CAN2 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const can1::RegisterBlock {
-        0x4000_6800 as *const _
-    }
-}
-impl Deref for CAN2 {
-    type Target = can1::RegisterBlock;
-    fn deref(&self) -> &can1::RegisterBlock {
-        unsafe { &*CAN2::ptr() }
-    }
-}
-#[doc = "CAN3"]
-pub struct CAN3 {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for CAN3 {}
-impl CAN3 {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const can1::RegisterBlock {
-        0x4000_6c00 as *const _
-    }
-}
-impl Deref for CAN3 {
-    type Target = can1::RegisterBlock;
-    fn deref(&self) -> &can1::RegisterBlock {
-        unsafe { &*CAN3::ptr() }
-    }
-}
-#[doc = "fast-mode Inter-integrated circuit"]
-pub struct FMPI2C {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for FMPI2C {}
-impl FMPI2C {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const fmpi2c::RegisterBlock {
-        0x4000_6000 as *const _
-    }
-}
-impl Deref for FMPI2C {
-    type Target = fmpi2c::RegisterBlock;
-    fn deref(&self) -> &fmpi2c::RegisterBlock {
-        unsafe { &*FMPI2C::ptr() }
-    }
-}
-#[doc = "fast-mode Inter-integrated circuit"]
-pub mod fmpi2c {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Control register 1"]
-        pub cr1: CR1,
-        #[doc = "0x04 - Control register 2"]
-        pub cr2: CR2,
-        #[doc = "0x08 - Own address register 1"]
-        pub oar1: OAR1,
-        #[doc = "0x0c - Own address register 2"]
-        pub oar2: OAR2,
-        #[doc = "0x10 - Timing register"]
-        pub timingr: TIMINGR,
-        #[doc = "0x14 - Timeout register"]
-        pub timeoutr: TIMEOUTR,
-        #[doc = "0x18 - Interrupt and Status register"]
-        pub isr: ISR,
-        #[doc = "0x1c - Interrupt clear register"]
-        pub icr: ICR,
-        #[doc = "0x20 - PEC register"]
-        pub pecr: PECR,
-        #[doc = "0x24 - Receive data register"]
-        pub rxdr: RXDR,
-        #[doc = "0x28 - Transmit data register"]
-        pub txdr: TXDR,
-    }
-    #[doc = "Control register 1"]
-    pub struct CR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register 1"]
-    pub mod cr1 {
-        #[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::CR1 {
-            #[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 = r" Value of the field"]
-        pub struct PER {
-            bits: bool,
-        }
-        impl PER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXIER {
-            bits: bool,
-        }
-        impl TXIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXIER {
-            bits: bool,
-        }
-        impl RXIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADDRER {
-            bits: bool,
-        }
-        impl ADDRER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NACKIER {
-            bits: bool,
-        }
-        impl NACKIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STOPIER {
-            bits: bool,
-        }
-        impl STOPIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ERRIER {
-            bits: bool,
-        }
-        impl ERRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DNFR {
-            bits: u8,
-        }
-        impl DNFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ANFOFFR {
-            bits: bool,
-        }
-        impl ANFOFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCDMAENR {
-            bits: bool,
-        }
-        impl TCDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXDMAENR {
-            bits: bool,
-        }
-        impl RXDMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SBCR {
-            bits: bool,
-        }
-        impl SBCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NOSTRETCHR {
-            bits: bool,
-        }
-        impl NOSTRETCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GCENR {
-            bits: bool,
-        }
-        impl GCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SMBHENR {
-            bits: bool,
-        }
-        impl SMBHENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SMBDENR {
-            bits: bool,
-        }
-        impl SMBDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALERTENR {
-            bits: bool,
-        }
-        impl ALERTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PECENR {
-            bits: bool,
-        }
-        impl PECENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _PEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADDREW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDREW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NACKIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NACKIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STOPIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STOPIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ERRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ERRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DNFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DNFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ANFOFFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ANFOFFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXDMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXDMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SBCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SBCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NOSTRETCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NOSTRETCHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SMBHENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMBHENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SMBDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMBDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALERTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALERTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PECENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PECENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Peripheral enable"]
-            #[inline]
-            pub fn pe(&self) -> PER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PER { bits }
-            }
-            #[doc = "Bit 1 - TXIE"]
-            #[inline]
-            pub fn txie(&self) -> TXIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXIER { bits }
-            }
-            #[doc = "Bit 2 - RXIE"]
-            #[inline]
-            pub fn rxie(&self) -> RXIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXIER { bits }
-            }
-            #[doc = "Bit 3 - ADDRE"]
-            #[inline]
-            pub fn addre(&self) -> ADDRER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADDRER { bits }
-            }
-            #[doc = "Bit 4 - NACKIE"]
-            #[inline]
-            pub fn nackie(&self) -> NACKIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NACKIER { bits }
-            }
-            #[doc = "Bit 5 - STOPIE"]
-            #[inline]
-            pub fn stopie(&self) -> STOPIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STOPIER { bits }
-            }
-            #[doc = "Bit 6 - TCIE"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 7 - ERRIE"]
-            #[inline]
-            pub fn errie(&self) -> ERRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ERRIER { bits }
-            }
-            #[doc = "Bits 8:11 - DNF"]
-            #[inline]
-            pub fn dnf(&self) -> DNFR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DNFR { bits }
-            }
-            #[doc = "Bit 12 - ANFOFF"]
-            #[inline]
-            pub fn anfoff(&self) -> ANFOFFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ANFOFFR { bits }
-            }
-            #[doc = "Bit 14 - TCDMAEN"]
-            #[inline]
-            pub fn tcdmaen(&self) -> TCDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCDMAENR { bits }
-            }
-            #[doc = "Bit 15 - RXDMAEN"]
-            #[inline]
-            pub fn rxdmaen(&self) -> RXDMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXDMAENR { bits }
-            }
-            #[doc = "Bit 16 - SBC"]
-            #[inline]
-            pub fn sbc(&self) -> SBCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SBCR { bits }
-            }
-            #[doc = "Bit 17 - NOSTRETCH"]
-            #[inline]
-            pub fn nostretch(&self) -> NOSTRETCHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NOSTRETCHR { bits }
-            }
-            #[doc = "Bit 19 - GCEN"]
-            #[inline]
-            pub fn gcen(&self) -> GCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GCENR { bits }
-            }
-            #[doc = "Bit 20 - SMBHEN"]
-            #[inline]
-            pub fn smbhen(&self) -> SMBHENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMBHENR { bits }
-            }
-            #[doc = "Bit 21 - SMBDEN"]
-            #[inline]
-            pub fn smbden(&self) -> SMBDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMBDENR { bits }
-            }
-            #[doc = "Bit 22 - ALERTEN"]
-            #[inline]
-            pub fn alerten(&self) -> ALERTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALERTENR { bits }
-            }
-            #[doc = "Bit 23 - PECEN"]
-            #[inline]
-            pub fn pecen(&self) -> PECENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PECENR { bits }
-            }
-        }
-        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 - Peripheral enable"]
-            #[inline]
-            pub fn pe(&mut self) -> _PEW {
-                _PEW { w: self }
-            }
-            #[doc = "Bit 1 - TXIE"]
-            #[inline]
-            pub fn txie(&mut self) -> _TXIEW {
-                _TXIEW { w: self }
-            }
-            #[doc = "Bit 2 - RXIE"]
-            #[inline]
-            pub fn rxie(&mut self) -> _RXIEW {
-                _RXIEW { w: self }
-            }
-            #[doc = "Bit 3 - ADDRE"]
-            #[inline]
-            pub fn addre(&mut self) -> _ADDREW {
-                _ADDREW { w: self }
-            }
-            #[doc = "Bit 4 - NACKIE"]
-            #[inline]
-            pub fn nackie(&mut self) -> _NACKIEW {
-                _NACKIEW { w: self }
-            }
-            #[doc = "Bit 5 - STOPIE"]
-            #[inline]
-            pub fn stopie(&mut self) -> _STOPIEW {
-                _STOPIEW { w: self }
-            }
-            #[doc = "Bit 6 - TCIE"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 7 - ERRIE"]
-            #[inline]
-            pub fn errie(&mut self) -> _ERRIEW {
-                _ERRIEW { w: self }
-            }
-            #[doc = "Bits 8:11 - DNF"]
-            #[inline]
-            pub fn dnf(&mut self) -> _DNFW {
-                _DNFW { w: self }
-            }
-            #[doc = "Bit 12 - ANFOFF"]
-            #[inline]
-            pub fn anfoff(&mut self) -> _ANFOFFW {
-                _ANFOFFW { w: self }
-            }
-            #[doc = "Bit 14 - TCDMAEN"]
-            #[inline]
-            pub fn tcdmaen(&mut self) -> _TCDMAENW {
-                _TCDMAENW { w: self }
-            }
-            #[doc = "Bit 15 - RXDMAEN"]
-            #[inline]
-            pub fn rxdmaen(&mut self) -> _RXDMAENW {
-                _RXDMAENW { w: self }
-            }
-            #[doc = "Bit 16 - SBC"]
-            #[inline]
-            pub fn sbc(&mut self) -> _SBCW {
-                _SBCW { w: self }
-            }
-            #[doc = "Bit 17 - NOSTRETCH"]
-            #[inline]
-            pub fn nostretch(&mut self) -> _NOSTRETCHW {
-                _NOSTRETCHW { w: self }
-            }
-            #[doc = "Bit 19 - GCEN"]
-            #[inline]
-            pub fn gcen(&mut self) -> _GCENW {
-                _GCENW { w: self }
-            }
-            #[doc = "Bit 20 - SMBHEN"]
-            #[inline]
-            pub fn smbhen(&mut self) -> _SMBHENW {
-                _SMBHENW { w: self }
-            }
-            #[doc = "Bit 21 - SMBDEN"]
-            #[inline]
-            pub fn smbden(&mut self) -> _SMBDENW {
-                _SMBDENW { w: self }
-            }
-            #[doc = "Bit 22 - ALERTEN"]
-            #[inline]
-            pub fn alerten(&mut self) -> _ALERTENW {
-                _ALERTENW { w: self }
-            }
-            #[doc = "Bit 23 - PECEN"]
-            #[inline]
-            pub fn pecen(&mut self) -> _PECENW {
-                _PECENW { w: self }
-            }
-        }
-    }
-    #[doc = "Control register 2"]
-    pub struct CR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control register 2"]
-    pub mod cr2 {
-        #[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::CR2 {
-            #[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 = r" Value of the field"]
-        pub struct SADD0R {
-            bits: bool,
-        }
-        impl SADD0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SADD1_7R {
-            bits: u8,
-        }
-        impl SADD1_7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SADD8_9R {
-            bits: u8,
-        }
-        impl SADD8_9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RD_WRNR {
-            bits: bool,
-        }
-        impl RD_WRNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADD10R {
-            bits: bool,
-        }
-        impl ADD10R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HEAD10RR {
-            bits: bool,
-        }
-        impl HEAD10RR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STARTR {
-            bits: bool,
-        }
-        impl STARTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STOPR {
-            bits: bool,
-        }
-        impl STOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NACKR {
-            bits: bool,
-        }
-        impl NACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NBYTESR {
-            bits: u8,
-        }
-        impl NBYTESR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RELOADR {
-            bits: bool,
-        }
-        impl RELOADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AUTOENDR {
-            bits: bool,
-        }
-        impl AUTOENDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PECBYTER {
-            bits: bool,
-        }
-        impl PECBYTER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SADD0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SADD0W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SADD1_7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SADD1_7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 1;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SADD8_9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SADD8_9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RD_WRNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RD_WRNW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADD10W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADD10W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HEAD10RW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HEAD10RW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STARTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STARTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STOPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STOPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NBYTESW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NBYTESW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RELOADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RELOADW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AUTOENDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AUTOENDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PECBYTEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PECBYTEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Slave address bit 0"]
-            #[inline]
-            pub fn sadd0(&self) -> SADD0R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SADD0R { bits }
-            }
-            #[doc = "Bits 1:7 - Slave address bit 7_1"]
-            #[inline]
-            pub fn sadd1_7(&self) -> SADD1_7R {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SADD1_7R { bits }
-            }
-            #[doc = "Bits 8:9 - Slave address bit 8_9"]
-            #[inline]
-            pub fn sadd8_9(&self) -> SADD8_9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SADD8_9R { bits }
-            }
-            #[doc = "Bit 10 - Transfer direction"]
-            #[inline]
-            pub fn rd_wrn(&self) -> RD_WRNR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RD_WRNR { bits }
-            }
-            #[doc = "Bit 11 - 10-bit addressing mode"]
-            #[inline]
-            pub fn add10(&self) -> ADD10R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADD10R { bits }
-            }
-            #[doc = "Bit 12 - 10-bit address header only read direction"]
-            #[inline]
-            pub fn head10r(&self) -> HEAD10RR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HEAD10RR { bits }
-            }
-            #[doc = "Bit 13 - Start generation"]
-            #[inline]
-            pub fn start(&self) -> STARTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STARTR { bits }
-            }
-            #[doc = "Bit 14 - Stop generation"]
-            #[inline]
-            pub fn stop(&self) -> STOPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STOPR { bits }
-            }
-            #[doc = "Bit 15 - NACK generation"]
-            #[inline]
-            pub fn nack(&self) -> NACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NACKR { bits }
-            }
-            #[doc = "Bits 16:23 - Number of bytes"]
-            #[inline]
-            pub fn nbytes(&self) -> NBYTESR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                NBYTESR { bits }
-            }
-            #[doc = "Bit 24 - NBYTES reload mode"]
-            #[inline]
-            pub fn reload(&self) -> RELOADR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RELOADR { bits }
-            }
-            #[doc = "Bit 25 - Automatic end mode"]
-            #[inline]
-            pub fn autoend(&self) -> AUTOENDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AUTOENDR { bits }
-            }
-            #[doc = "Bit 26 - Packet error checking byte"]
-            #[inline]
-            pub fn pecbyte(&self) -> PECBYTER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PECBYTER { bits }
-            }
-        }
-        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 - Slave address bit 0"]
-            #[inline]
-            pub fn sadd0(&mut self) -> _SADD0W {
-                _SADD0W { w: self }
-            }
-            #[doc = "Bits 1:7 - Slave address bit 7_1"]
-            #[inline]
-            pub fn sadd1_7(&mut self) -> _SADD1_7W {
-                _SADD1_7W { w: self }
-            }
-            #[doc = "Bits 8:9 - Slave address bit 8_9"]
-            #[inline]
-            pub fn sadd8_9(&mut self) -> _SADD8_9W {
-                _SADD8_9W { w: self }
-            }
-            #[doc = "Bit 10 - Transfer direction"]
-            #[inline]
-            pub fn rd_wrn(&mut self) -> _RD_WRNW {
-                _RD_WRNW { w: self }
-            }
-            #[doc = "Bit 11 - 10-bit addressing mode"]
-            #[inline]
-            pub fn add10(&mut self) -> _ADD10W {
-                _ADD10W { w: self }
-            }
-            #[doc = "Bit 12 - 10-bit address header only read direction"]
-            #[inline]
-            pub fn head10r(&mut self) -> _HEAD10RW {
-                _HEAD10RW { w: self }
-            }
-            #[doc = "Bit 13 - Start generation"]
-            #[inline]
-            pub fn start(&mut self) -> _STARTW {
-                _STARTW { w: self }
-            }
-            #[doc = "Bit 14 - Stop generation"]
-            #[inline]
-            pub fn stop(&mut self) -> _STOPW {
-                _STOPW { w: self }
-            }
-            #[doc = "Bit 15 - NACK generation"]
-            #[inline]
-            pub fn nack(&mut self) -> _NACKW {
-                _NACKW { w: self }
-            }
-            #[doc = "Bits 16:23 - Number of bytes"]
-            #[inline]
-            pub fn nbytes(&mut self) -> _NBYTESW {
-                _NBYTESW { w: self }
-            }
-            #[doc = "Bit 24 - NBYTES reload mode"]
-            #[inline]
-            pub fn reload(&mut self) -> _RELOADW {
-                _RELOADW { w: self }
-            }
-            #[doc = "Bit 25 - Automatic end mode"]
-            #[inline]
-            pub fn autoend(&mut self) -> _AUTOENDW {
-                _AUTOENDW { w: self }
-            }
-            #[doc = "Bit 26 - Packet error checking byte"]
-            #[inline]
-            pub fn pecbyte(&mut self) -> _PECBYTEW {
-                _PECBYTEW { w: self }
-            }
-        }
-    }
-    #[doc = "Own address register 1"]
-    pub struct OAR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Own address register 1"]
-    pub mod oar1 {
-        #[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::OAR1 {
-            #[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 = r" Value of the field"]
-        pub struct OA1R {
-            bits: bool,
-        }
-        impl OA1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OA11_7R {
-            bits: u8,
-        }
-        impl OA11_7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OA18_9R {
-            bits: u8,
-        }
-        impl OA18_9R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OA1MODER {
-            bits: bool,
-        }
-        impl OA1MODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OA1ENR {
-            bits: bool,
-        }
-        impl OA1ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OA1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OA1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OA11_7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OA11_7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 1;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OA18_9W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OA18_9W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OA1MODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OA1MODEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OA1ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OA1ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - OA1"]
-            #[inline]
-            pub fn oa1(&self) -> OA1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OA1R { bits }
-            }
-            #[doc = "Bits 1:7 - OA11_7"]
-            #[inline]
-            pub fn oa11_7(&self) -> OA11_7R {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OA11_7R { bits }
-            }
-            #[doc = "Bits 8:9 - OA18_9"]
-            #[inline]
-            pub fn oa18_9(&self) -> OA18_9R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OA18_9R { bits }
-            }
-            #[doc = "Bit 10 - OA1MODE"]
-            #[inline]
-            pub fn oa1mode(&self) -> OA1MODER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OA1MODER { bits }
-            }
-            #[doc = "Bit 15 - OA1EN"]
-            #[inline]
-            pub fn oa1en(&self) -> OA1ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OA1ENR { bits }
-            }
-        }
-        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 - OA1"]
-            #[inline]
-            pub fn oa1(&mut self) -> _OA1W {
-                _OA1W { w: self }
-            }
-            #[doc = "Bits 1:7 - OA11_7"]
-            #[inline]
-            pub fn oa11_7(&mut self) -> _OA11_7W {
-                _OA11_7W { w: self }
-            }
-            #[doc = "Bits 8:9 - OA18_9"]
-            #[inline]
-            pub fn oa18_9(&mut self) -> _OA18_9W {
-                _OA18_9W { w: self }
-            }
-            #[doc = "Bit 10 - OA1MODE"]
-            #[inline]
-            pub fn oa1mode(&mut self) -> _OA1MODEW {
-                _OA1MODEW { w: self }
-            }
-            #[doc = "Bit 15 - OA1EN"]
-            #[inline]
-            pub fn oa1en(&mut self) -> _OA1ENW {
-                _OA1ENW { w: self }
-            }
-        }
-    }
-    #[doc = "Own address register 2"]
-    pub struct OAR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Own address register 2"]
-    pub mod oar2 {
-        #[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::OAR2 {
-            #[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 = r" Value of the field"]
-        pub struct OA21_7R {
-            bits: u8,
-        }
-        impl OA21_7R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OA2MSKR {
-            bits: u8,
-        }
-        impl OA2MSKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OA2ENR {
-            bits: bool,
-        }
-        impl OA2ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _OA21_7W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OA21_7W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 1;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OA2MSKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OA2MSKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OA2ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OA2ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 1:7 - OA21_7"]
-            #[inline]
-            pub fn oa21_7(&self) -> OA21_7R {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OA21_7R { bits }
-            }
-            #[doc = "Bits 8:10 - OA2MSK"]
-            #[inline]
-            pub fn oa2msk(&self) -> OA2MSKR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                OA2MSKR { bits }
-            }
-            #[doc = "Bit 15 - OA2EN"]
-            #[inline]
-            pub fn oa2en(&self) -> OA2ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OA2ENR { bits }
-            }
-        }
-        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 1:7 - OA21_7"]
-            #[inline]
-            pub fn oa21_7(&mut self) -> _OA21_7W {
-                _OA21_7W { w: self }
-            }
-            #[doc = "Bits 8:10 - OA2MSK"]
-            #[inline]
-            pub fn oa2msk(&mut self) -> _OA2MSKW {
-                _OA2MSKW { w: self }
-            }
-            #[doc = "Bit 15 - OA2EN"]
-            #[inline]
-            pub fn oa2en(&mut self) -> _OA2ENW {
-                _OA2ENW { w: self }
-            }
-        }
-    }
-    #[doc = "Timing register"]
-    pub struct TIMINGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Timing register"]
-    pub mod timingr {
-        #[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::TIMINGR {
-            #[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 = r" Value of the field"]
-        pub struct SCLLR {
-            bits: u8,
-        }
-        impl SCLLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCLHR {
-            bits: u8,
-        }
-        impl SCLHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SDADELR {
-            bits: u8,
-        }
-        impl SDADELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SCLDELR {
-            bits: u8,
-        }
-        impl SCLDELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PRESCR {
-            bits: u8,
-        }
-        impl PRESCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCLLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCLLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCLHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCLHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SDADELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDADELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SCLDELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SCLDELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PRESCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRESCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 28;
-                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 0:7 - SCLL"]
-            #[inline]
-            pub fn scll(&self) -> SCLLR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCLLR { bits }
-            }
-            #[doc = "Bits 8:15 - SCLH"]
-            #[inline]
-            pub fn sclh(&self) -> SCLHR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCLHR { bits }
-            }
-            #[doc = "Bits 16:19 - SDADEL"]
-            #[inline]
-            pub fn sdadel(&self) -> SDADELR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SDADELR { bits }
-            }
-            #[doc = "Bits 20:23 - SCLDEL"]
-            #[inline]
-            pub fn scldel(&self) -> SCLDELR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SCLDELR { bits }
-            }
-            #[doc = "Bits 28:31 - PRESC"]
-            #[inline]
-            pub fn presc(&self) -> PRESCR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PRESCR { bits }
-            }
-        }
-        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 0:7 - SCLL"]
-            #[inline]
-            pub fn scll(&mut self) -> _SCLLW {
-                _SCLLW { w: self }
-            }
-            #[doc = "Bits 8:15 - SCLH"]
-            #[inline]
-            pub fn sclh(&mut self) -> _SCLHW {
-                _SCLHW { w: self }
-            }
-            #[doc = "Bits 16:19 - SDADEL"]
-            #[inline]
-            pub fn sdadel(&mut self) -> _SDADELW {
-                _SDADELW { w: self }
-            }
-            #[doc = "Bits 20:23 - SCLDEL"]
-            #[inline]
-            pub fn scldel(&mut self) -> _SCLDELW {
-                _SCLDELW { w: self }
-            }
-            #[doc = "Bits 28:31 - PRESC"]
-            #[inline]
-            pub fn presc(&mut self) -> _PRESCW {
-                _PRESCW { w: self }
-            }
-        }
-    }
-    #[doc = "Timeout register"]
-    pub struct TIMEOUTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Timeout register"]
-    pub mod timeoutr {
-        #[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::TIMEOUTR {
-            #[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 = r" Value of the field"]
-        pub struct TIMEOUTAR {
-            bits: u16,
-        }
-        impl TIMEOUTAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TIDLER {
-            bits: bool,
-        }
-        impl TIDLER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIMOUTENR {
-            bits: bool,
-        }
-        impl TIMOUTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIMEOUTBR {
-            bits: u16,
-        }
-        impl TIMEOUTBR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TEXTENR {
-            bits: bool,
-        }
-        impl TEXTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TIMEOUTAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMEOUTAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TIDLEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIDLEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIMOUTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMOUTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIMEOUTBW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMEOUTBW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TEXTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEXTENW<'a> {
-            #[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 = "Bits 0:11 - TIMEOUTA"]
-            #[inline]
-            pub fn timeouta(&self) -> TIMEOUTAR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TIMEOUTAR { bits }
-            }
-            #[doc = "Bit 12 - TIDLE"]
-            #[inline]
-            pub fn tidle(&self) -> TIDLER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIDLER { bits }
-            }
-            #[doc = "Bit 15 - TIMOUTEN"]
-            #[inline]
-            pub fn timouten(&self) -> TIMOUTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIMOUTENR { bits }
-            }
-            #[doc = "Bits 16:27 - TIMEOUTB"]
-            #[inline]
-            pub fn timeoutb(&self) -> TIMEOUTBR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TIMEOUTBR { bits }
-            }
-            #[doc = "Bit 31 - TEXTEN"]
-            #[inline]
-            pub fn texten(&self) -> TEXTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEXTENR { bits }
-            }
-        }
-        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 0:11 - TIMEOUTA"]
-            #[inline]
-            pub fn timeouta(&mut self) -> _TIMEOUTAW {
-                _TIMEOUTAW { w: self }
-            }
-            #[doc = "Bit 12 - TIDLE"]
-            #[inline]
-            pub fn tidle(&mut self) -> _TIDLEW {
-                _TIDLEW { w: self }
-            }
-            #[doc = "Bit 15 - TIMOUTEN"]
-            #[inline]
-            pub fn timouten(&mut self) -> _TIMOUTENW {
-                _TIMOUTENW { w: self }
-            }
-            #[doc = "Bits 16:27 - TIMEOUTB"]
-            #[inline]
-            pub fn timeoutb(&mut self) -> _TIMEOUTBW {
-                _TIMEOUTBW { w: self }
-            }
-            #[doc = "Bit 31 - TEXTEN"]
-            #[inline]
-            pub fn texten(&mut self) -> _TEXTENW {
-                _TEXTENW { w: self }
-            }
-        }
-    }
-    #[doc = "Interrupt and Status register"]
-    pub struct ISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Interrupt and Status register"]
-    pub mod isr {
-        #[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::ISR {
-            #[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 = r" Value of the field"]
-        pub struct TXER {
-            bits: bool,
-        }
-        impl TXER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXISR {
-            bits: bool,
-        }
-        impl TXISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXNER {
-            bits: bool,
-        }
-        impl RXNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADDRR {
-            bits: bool,
-        }
-        impl ADDRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NACKFR {
-            bits: bool,
-        }
-        impl NACKFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STOPFR {
-            bits: bool,
-        }
-        impl STOPFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCR {
-            bits: bool,
-        }
-        impl TCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCRR {
-            bits: bool,
-        }
-        impl TCRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BERRR {
-            bits: bool,
-        }
-        impl BERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ARLOR {
-            bits: bool,
-        }
-        impl ARLOR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVRR {
-            bits: bool,
-        }
-        impl OVRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PECERRR {
-            bits: bool,
-        }
-        impl PECERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIMEOUTR {
-            bits: bool,
-        }
-        impl TIMEOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ALERTR {
-            bits: bool,
-        }
-        impl ALERTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BUSYR {
-            bits: bool,
-        }
-        impl BUSYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DIRR {
-            bits: bool,
-        }
-        impl DIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADDCODER {
-            bits: u8,
-        }
-        impl ADDCODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TXEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXISW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - TXE"]
-            #[inline]
-            pub fn txe(&self) -> TXER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXER { bits }
-            }
-            #[doc = "Bit 1 - TXIS"]
-            #[inline]
-            pub fn txis(&self) -> TXISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXISR { bits }
-            }
-            #[doc = "Bit 2 - RXNE"]
-            #[inline]
-            pub fn rxne(&self) -> RXNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXNER { bits }
-            }
-            #[doc = "Bit 3 - ADDR"]
-            #[inline]
-            pub fn addr(&self) -> ADDRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADDRR { bits }
-            }
-            #[doc = "Bit 4 - NACKF"]
-            #[inline]
-            pub fn nackf(&self) -> NACKFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NACKFR { bits }
-            }
-            #[doc = "Bit 5 - STOPF"]
-            #[inline]
-            pub fn stopf(&self) -> STOPFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STOPFR { bits }
-            }
-            #[doc = "Bit 6 - TC"]
-            #[inline]
-            pub fn tc(&self) -> TCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCR { bits }
-            }
-            #[doc = "Bit 7 - TCR"]
-            #[inline]
-            pub fn tcr(&self) -> TCRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCRR { bits }
-            }
-            #[doc = "Bit 8 - BERR"]
-            #[inline]
-            pub fn berr(&self) -> BERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BERRR { bits }
-            }
-            #[doc = "Bit 9 - ARLO"]
-            #[inline]
-            pub fn arlo(&self) -> ARLOR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARLOR { bits }
-            }
-            #[doc = "Bit 10 - OVR"]
-            #[inline]
-            pub fn ovr(&self) -> OVRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRR { bits }
-            }
-            #[doc = "Bit 11 - PECERR"]
-            #[inline]
-            pub fn pecerr(&self) -> PECERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PECERRR { bits }
-            }
-            #[doc = "Bit 12 - TIMEOUT"]
-            #[inline]
-            pub fn timeout(&self) -> TIMEOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIMEOUTR { bits }
-            }
-            #[doc = "Bit 13 - ALERT"]
-            #[inline]
-            pub fn alert(&self) -> ALERTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ALERTR { bits }
-            }
-            #[doc = "Bit 15 - BUSY"]
-            #[inline]
-            pub fn busy(&self) -> BUSYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BUSYR { bits }
-            }
-            #[doc = "Bit 16 - DIR"]
-            #[inline]
-            pub fn dir(&self) -> DIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DIRR { bits }
-            }
-            #[doc = "Bits 17:23 - ADDCODE"]
-            #[inline]
-            pub fn addcode(&self) -> ADDCODER {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDCODER { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x01 }
-            }
-            #[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 - TXE"]
-            #[inline]
-            pub fn txe(&mut self) -> _TXEW {
-                _TXEW { w: self }
-            }
-            #[doc = "Bit 1 - TXIS"]
-            #[inline]
-            pub fn txis(&mut self) -> _TXISW {
-                _TXISW { w: self }
-            }
-        }
-    }
-    #[doc = "Interrupt clear register"]
-    pub struct ICR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Interrupt clear register"]
-    pub mod icr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::ICR {
-            #[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" Proxy"]
-        pub struct _ADDRCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDRCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NACKCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NACKCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STOPCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STOPCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BERRCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BERRCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ARLOCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARLOCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OVRCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PECCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PECCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIMOUTCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMOUTCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ALERTCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALERTCFW<'a> {
-            #[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
-            }
-        }
-        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 3 - Address matched flag clear"]
-            #[inline]
-            pub fn addrcf(&mut self) -> _ADDRCFW {
-                _ADDRCFW { w: self }
-            }
-            #[doc = "Bit 4 - Not Acknowledge flag clear"]
-            #[inline]
-            pub fn nackcf(&mut self) -> _NACKCFW {
-                _NACKCFW { w: self }
-            }
-            #[doc = "Bit 5 - Stop detection flag clear"]
-            #[inline]
-            pub fn stopcf(&mut self) -> _STOPCFW {
-                _STOPCFW { w: self }
-            }
-            #[doc = "Bit 8 - Bus error flag clear"]
-            #[inline]
-            pub fn berrcf(&mut self) -> _BERRCFW {
-                _BERRCFW { w: self }
-            }
-            #[doc = "Bit 9 - Arbitration Lost flag clear"]
-            #[inline]
-            pub fn arlocf(&mut self) -> _ARLOCFW {
-                _ARLOCFW { w: self }
-            }
-            #[doc = "Bit 10 - Overrun/Underrun flag clear"]
-            #[inline]
-            pub fn ovrcf(&mut self) -> _OVRCFW {
-                _OVRCFW { w: self }
-            }
-            #[doc = "Bit 11 - PEC Error flag clear"]
-            #[inline]
-            pub fn peccf(&mut self) -> _PECCFW {
-                _PECCFW { w: self }
-            }
-            #[doc = "Bit 12 - Timeout detection flag clear"]
-            #[inline]
-            pub fn timoutcf(&mut self) -> _TIMOUTCFW {
-                _TIMOUTCFW { w: self }
-            }
-            #[doc = "Bit 13 - Alert flag clear"]
-            #[inline]
-            pub fn alertcf(&mut self) -> _ALERTCFW {
-                _ALERTCFW { w: self }
-            }
-        }
-    }
-    #[doc = "PEC register"]
-    pub struct PECR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "PEC register"]
-    pub mod pecr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::PECR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PECR {
-            bits: u8,
-        }
-        impl PECR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:7 - PEC"]
-            #[inline]
-            pub fn pec(&self) -> PECR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PECR { bits }
-            }
-        }
-    }
-    #[doc = "Receive data register"]
-    pub struct RXDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Receive data register"]
-    pub mod rxdr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::RXDR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct RXDATAR {
-            bits: u8,
-        }
-        impl RXDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:7 - RXDATA"]
-            #[inline]
-            pub fn rxdata(&self) -> RXDATAR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RXDATAR { bits }
-            }
-        }
-    }
-    #[doc = "Transmit data register"]
-    pub struct TXDR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Transmit data register"]
-    pub mod txdr {
-        #[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::TXDR {
-            #[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 = r" Value of the field"]
-        pub struct TXDATAR {
-            bits: u8,
-        }
-        impl TXDATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TXDATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXDATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - TXDATA"]
-            #[inline]
-            pub fn txdata(&self) -> TXDATAR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TXDATAR { bits }
-            }
-        }
-        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 0:7 - TXDATA"]
-            #[inline]
-            pub fn txdata(&mut self) -> _TXDATAW {
-                _TXDATAW { w: self }
-            }
-        }
-    }
-}
-#[doc = "Flexible static memory controller"]
-pub struct FSMC {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for FSMC {}
-impl FSMC {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const fsmc::RegisterBlock {
-        0xa000_0000 as *const _
-    }
-}
-impl Deref for FSMC {
-    type Target = fsmc::RegisterBlock;
-    fn deref(&self) -> &fsmc::RegisterBlock {
-        unsafe { &*FSMC::ptr() }
-    }
-}
-#[doc = "Flexible static memory controller"]
-pub mod fsmc {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - SRAM/NOR-Flash chip-select control register 1"]
-        pub bcr1: BCR1,
-        #[doc = "0x04 - SRAM/NOR-Flash chip-select timing register 1"]
-        pub btr1: BTR1,
-        #[doc = "0x08 - SRAM/NOR-Flash chip-select control register 2"]
-        pub bcr2: BCR2,
-        #[doc = "0x0c - SRAM/NOR-Flash chip-select timing register 2"]
-        pub btr2: BTR2,
-        #[doc = "0x10 - SRAM/NOR-Flash chip-select control register 3"]
-        pub bcr3: BCR3,
-        #[doc = "0x14 - SRAM/NOR-Flash chip-select timing register 3"]
-        pub btr3: BTR3,
-        #[doc = "0x18 - SRAM/NOR-Flash chip-select control register 4"]
-        pub bcr4: BCR4,
-        #[doc = "0x1c - SRAM/NOR-Flash chip-select timing register 4"]
-        pub btr4: BTR4,
-        _reserved0: [u8; 64usize],
-        #[doc = "0x60 - PC Card/NAND Flash control register 2"]
-        pub pcr2: PCR2,
-        #[doc = "0x64 - FIFO status and interrupt register 2"]
-        pub sr2: SR2,
-        #[doc = "0x68 - Common memory space timing register 2"]
-        pub pmem2: PMEM2,
-        #[doc = "0x6c - Attribute memory space timing register 2"]
-        pub patt2: PATT2,
-        _reserved1: [u8; 4usize],
-        #[doc = "0x74 - ECC result register 2"]
-        pub eccr2: ECCR2,
-        _reserved2: [u8; 8usize],
-        #[doc = "0x80 - PC Card/NAND Flash control register 3"]
-        pub pcr3: PCR3,
-        #[doc = "0x84 - FIFO status and interrupt register 3"]
-        pub sr3: SR3,
-        #[doc = "0x88 - Common memory space timing register 3"]
-        pub pmem3: PMEM3,
-        #[doc = "0x8c - Attribute memory space timing register 3"]
-        pub patt3: PATT3,
-        _reserved3: [u8; 4usize],
-        #[doc = "0x94 - ECC result register 3"]
-        pub eccr3: ECCR3,
-        _reserved4: [u8; 8usize],
-        #[doc = "0xa0 - PC Card/NAND Flash control register 4"]
-        pub pcr4: PCR4,
-        #[doc = "0xa4 - FIFO status and interrupt register 4"]
-        pub sr4: SR4,
-        #[doc = "0xa8 - Common memory space timing register 4"]
-        pub pmem4: PMEM4,
-        #[doc = "0xac - Attribute memory space timing register 4"]
-        pub patt4: PATT4,
-        #[doc = "0xb0 - I/O space timing register 4"]
-        pub pio4: PIO4,
-        _reserved5: [u8; 80usize],
-        #[doc = "0x104 - SRAM/NOR-Flash write timing registers 1"]
-        pub bwtr1: BWTR1,
-        _reserved6: [u8; 4usize],
-        #[doc = "0x10c - SRAM/NOR-Flash write timing registers 2"]
-        pub bwtr2: BWTR2,
-        _reserved7: [u8; 4usize],
-        #[doc = "0x114 - SRAM/NOR-Flash write timing registers 3"]
-        pub bwtr3: BWTR3,
-        _reserved8: [u8; 4usize],
-        #[doc = "0x11c - SRAM/NOR-Flash write timing registers 4"]
-        pub bwtr4: BWTR4,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select control register 1"]
-    pub struct BCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select control register 1"]
-    pub mod bcr1 {
-        #[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::BCR1 {
-            #[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 = r" Value of the field"]
-        pub struct CBURSTRWR {
-            bits: bool,
-        }
-        impl CBURSTRWR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ASYNCWAITR {
-            bits: bool,
-        }
-        impl ASYNCWAITR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EXTMODR {
-            bits: bool,
-        }
-        impl EXTMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITENR {
-            bits: bool,
-        }
-        impl WAITENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WRENR {
-            bits: bool,
-        }
-        impl WRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITCFGR {
-            bits: bool,
-        }
-        impl WAITCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITPOLR {
-            bits: bool,
-        }
-        impl WAITPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BURSTENR {
-            bits: bool,
-        }
-        impl BURSTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACCENR {
-            bits: bool,
-        }
-        impl FACCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MWIDR {
-            bits: u8,
-        }
-        impl MWIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MTYPR {
-            bits: u8,
-        }
-        impl MTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MUXENR {
-            bits: bool,
-        }
-        impl MUXENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MBKENR {
-            bits: bool,
-        }
-        impl MBKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CBURSTRWW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CBURSTRWW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ASYNCWAITW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ASYNCWAITW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EXTMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BURSTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BURSTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MWIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MWIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MUXENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUXENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MBKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBKENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 19 - CBURSTRW"]
-            #[inline]
-            pub fn cburstrw(&self) -> CBURSTRWR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CBURSTRWR { bits }
-            }
-            #[doc = "Bit 15 - ASYNCWAIT"]
-            #[inline]
-            pub fn asyncwait(&self) -> ASYNCWAITR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ASYNCWAITR { bits }
-            }
-            #[doc = "Bit 14 - EXTMOD"]
-            #[inline]
-            pub fn extmod(&self) -> EXTMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EXTMODR { bits }
-            }
-            #[doc = "Bit 13 - WAITEN"]
-            #[inline]
-            pub fn waiten(&self) -> WAITENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITENR { bits }
-            }
-            #[doc = "Bit 12 - WREN"]
-            #[inline]
-            pub fn wren(&self) -> WRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRENR { bits }
-            }
-            #[doc = "Bit 11 - WAITCFG"]
-            #[inline]
-            pub fn waitcfg(&self) -> WAITCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITCFGR { bits }
-            }
-            #[doc = "Bit 9 - WAITPOL"]
-            #[inline]
-            pub fn waitpol(&self) -> WAITPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITPOLR { bits }
-            }
-            #[doc = "Bit 8 - BURSTEN"]
-            #[inline]
-            pub fn bursten(&self) -> BURSTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BURSTENR { bits }
-            }
-            #[doc = "Bit 6 - FACCEN"]
-            #[inline]
-            pub fn faccen(&self) -> FACCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACCENR { bits }
-            }
-            #[doc = "Bits 4:5 - MWID"]
-            #[inline]
-            pub fn mwid(&self) -> MWIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MWIDR { bits }
-            }
-            #[doc = "Bits 2:3 - MTYP"]
-            #[inline]
-            pub fn mtyp(&self) -> MTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MTYPR { bits }
-            }
-            #[doc = "Bit 1 - MUXEN"]
-            #[inline]
-            pub fn muxen(&self) -> MUXENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUXENR { bits }
-            }
-            #[doc = "Bit 0 - MBKEN"]
-            #[inline]
-            pub fn mbken(&self) -> MBKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MBKENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x30d0 }
-            }
-            #[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 19 - CBURSTRW"]
-            #[inline]
-            pub fn cburstrw(&mut self) -> _CBURSTRWW {
-                _CBURSTRWW { w: self }
-            }
-            #[doc = "Bit 15 - ASYNCWAIT"]
-            #[inline]
-            pub fn asyncwait(&mut self) -> _ASYNCWAITW {
-                _ASYNCWAITW { w: self }
-            }
-            #[doc = "Bit 14 - EXTMOD"]
-            #[inline]
-            pub fn extmod(&mut self) -> _EXTMODW {
-                _EXTMODW { w: self }
-            }
-            #[doc = "Bit 13 - WAITEN"]
-            #[inline]
-            pub fn waiten(&mut self) -> _WAITENW {
-                _WAITENW { w: self }
-            }
-            #[doc = "Bit 12 - WREN"]
-            #[inline]
-            pub fn wren(&mut self) -> _WRENW {
-                _WRENW { w: self }
-            }
-            #[doc = "Bit 11 - WAITCFG"]
-            #[inline]
-            pub fn waitcfg(&mut self) -> _WAITCFGW {
-                _WAITCFGW { w: self }
-            }
-            #[doc = "Bit 9 - WAITPOL"]
-            #[inline]
-            pub fn waitpol(&mut self) -> _WAITPOLW {
-                _WAITPOLW { w: self }
-            }
-            #[doc = "Bit 8 - BURSTEN"]
-            #[inline]
-            pub fn bursten(&mut self) -> _BURSTENW {
-                _BURSTENW { w: self }
-            }
-            #[doc = "Bit 6 - FACCEN"]
-            #[inline]
-            pub fn faccen(&mut self) -> _FACCENW {
-                _FACCENW { w: self }
-            }
-            #[doc = "Bits 4:5 - MWID"]
-            #[inline]
-            pub fn mwid(&mut self) -> _MWIDW {
-                _MWIDW { w: self }
-            }
-            #[doc = "Bits 2:3 - MTYP"]
-            #[inline]
-            pub fn mtyp(&mut self) -> _MTYPW {
-                _MTYPW { w: self }
-            }
-            #[doc = "Bit 1 - MUXEN"]
-            #[inline]
-            pub fn muxen(&mut self) -> _MUXENW {
-                _MUXENW { w: self }
-            }
-            #[doc = "Bit 0 - MBKEN"]
-            #[inline]
-            pub fn mbken(&mut self) -> _MBKENW {
-                _MBKENW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash chip-select timing register 1"]
-    pub struct BTR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select timing register 1"]
-    pub mod btr1 {
-        #[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::BTR1 {
-            #[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 = r" Value of the field"]
-        pub struct ACCMODR {
-            bits: u8,
-        }
-        impl ACCMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATLATR {
-            bits: u8,
-        }
-        impl DATLATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BUSTURNR {
-            bits: u8,
-        }
-        impl BUSTURNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATASTR {
-            bits: u8,
-        }
-        impl DATASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDHLDR {
-            bits: u8,
-        }
-        impl ADDHLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDSETR {
-            bits: u8,
-        }
-        impl ADDSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACCMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACCMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATLATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLATW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BUSTURNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BUSTURNW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATASTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDHLDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDHLDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&self) -> ACCMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ACCMODR { bits }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&self) -> DATLATR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLATR { bits }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-            #[doc = "Bits 16:19 - BUSTURN"]
-            #[inline]
-            pub fn busturn(&self) -> BUSTURNR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BUSTURNR { bits }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&self) -> DATASTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATASTR { bits }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&self) -> ADDHLDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDHLDR { bits }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&self) -> ADDSETR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDSETR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xffff_ffff }
-            }
-            #[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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&mut self) -> _ACCMODW {
-                _ACCMODW { w: self }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&mut self) -> _DATLATW {
-                _DATLATW { w: self }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-            #[doc = "Bits 16:19 - BUSTURN"]
-            #[inline]
-            pub fn busturn(&mut self) -> _BUSTURNW {
-                _BUSTURNW { w: self }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&mut self) -> _DATASTW {
-                _DATASTW { w: self }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&mut self) -> _ADDHLDW {
-                _ADDHLDW { w: self }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&mut self) -> _ADDSETW {
-                _ADDSETW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash chip-select control register 2"]
-    pub struct BCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select control register 2"]
-    pub mod bcr2 {
-        #[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::BCR2 {
-            #[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 = r" Value of the field"]
-        pub struct CBURSTRWR {
-            bits: bool,
-        }
-        impl CBURSTRWR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ASYNCWAITR {
-            bits: bool,
-        }
-        impl ASYNCWAITR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EXTMODR {
-            bits: bool,
-        }
-        impl EXTMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITENR {
-            bits: bool,
-        }
-        impl WAITENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WRENR {
-            bits: bool,
-        }
-        impl WRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITCFGR {
-            bits: bool,
-        }
-        impl WAITCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WRAPMODR {
-            bits: bool,
-        }
-        impl WRAPMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITPOLR {
-            bits: bool,
-        }
-        impl WAITPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BURSTENR {
-            bits: bool,
-        }
-        impl BURSTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACCENR {
-            bits: bool,
-        }
-        impl FACCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MWIDR {
-            bits: u8,
-        }
-        impl MWIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MTYPR {
-            bits: u8,
-        }
-        impl MTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MUXENR {
-            bits: bool,
-        }
-        impl MUXENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MBKENR {
-            bits: bool,
-        }
-        impl MBKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CBURSTRWW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CBURSTRWW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ASYNCWAITW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ASYNCWAITW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EXTMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WRAPMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WRAPMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BURSTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BURSTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MWIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MWIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MUXENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUXENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MBKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBKENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 19 - CBURSTRW"]
-            #[inline]
-            pub fn cburstrw(&self) -> CBURSTRWR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CBURSTRWR { bits }
-            }
-            #[doc = "Bit 15 - ASYNCWAIT"]
-            #[inline]
-            pub fn asyncwait(&self) -> ASYNCWAITR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ASYNCWAITR { bits }
-            }
-            #[doc = "Bit 14 - EXTMOD"]
-            #[inline]
-            pub fn extmod(&self) -> EXTMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EXTMODR { bits }
-            }
-            #[doc = "Bit 13 - WAITEN"]
-            #[inline]
-            pub fn waiten(&self) -> WAITENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITENR { bits }
-            }
-            #[doc = "Bit 12 - WREN"]
-            #[inline]
-            pub fn wren(&self) -> WRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRENR { bits }
-            }
-            #[doc = "Bit 11 - WAITCFG"]
-            #[inline]
-            pub fn waitcfg(&self) -> WAITCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITCFGR { bits }
-            }
-            #[doc = "Bit 10 - WRAPMOD"]
-            #[inline]
-            pub fn wrapmod(&self) -> WRAPMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRAPMODR { bits }
-            }
-            #[doc = "Bit 9 - WAITPOL"]
-            #[inline]
-            pub fn waitpol(&self) -> WAITPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITPOLR { bits }
-            }
-            #[doc = "Bit 8 - BURSTEN"]
-            #[inline]
-            pub fn bursten(&self) -> BURSTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BURSTENR { bits }
-            }
-            #[doc = "Bit 6 - FACCEN"]
-            #[inline]
-            pub fn faccen(&self) -> FACCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACCENR { bits }
-            }
-            #[doc = "Bits 4:5 - MWID"]
-            #[inline]
-            pub fn mwid(&self) -> MWIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MWIDR { bits }
-            }
-            #[doc = "Bits 2:3 - MTYP"]
-            #[inline]
-            pub fn mtyp(&self) -> MTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MTYPR { bits }
-            }
-            #[doc = "Bit 1 - MUXEN"]
-            #[inline]
-            pub fn muxen(&self) -> MUXENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUXENR { bits }
-            }
-            #[doc = "Bit 0 - MBKEN"]
-            #[inline]
-            pub fn mbken(&self) -> MBKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MBKENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x30d0 }
-            }
-            #[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 19 - CBURSTRW"]
-            #[inline]
-            pub fn cburstrw(&mut self) -> _CBURSTRWW {
-                _CBURSTRWW { w: self }
-            }
-            #[doc = "Bit 15 - ASYNCWAIT"]
-            #[inline]
-            pub fn asyncwait(&mut self) -> _ASYNCWAITW {
-                _ASYNCWAITW { w: self }
-            }
-            #[doc = "Bit 14 - EXTMOD"]
-            #[inline]
-            pub fn extmod(&mut self) -> _EXTMODW {
-                _EXTMODW { w: self }
-            }
-            #[doc = "Bit 13 - WAITEN"]
-            #[inline]
-            pub fn waiten(&mut self) -> _WAITENW {
-                _WAITENW { w: self }
-            }
-            #[doc = "Bit 12 - WREN"]
-            #[inline]
-            pub fn wren(&mut self) -> _WRENW {
-                _WRENW { w: self }
-            }
-            #[doc = "Bit 11 - WAITCFG"]
-            #[inline]
-            pub fn waitcfg(&mut self) -> _WAITCFGW {
-                _WAITCFGW { w: self }
-            }
-            #[doc = "Bit 10 - WRAPMOD"]
-            #[inline]
-            pub fn wrapmod(&mut self) -> _WRAPMODW {
-                _WRAPMODW { w: self }
-            }
-            #[doc = "Bit 9 - WAITPOL"]
-            #[inline]
-            pub fn waitpol(&mut self) -> _WAITPOLW {
-                _WAITPOLW { w: self }
-            }
-            #[doc = "Bit 8 - BURSTEN"]
-            #[inline]
-            pub fn bursten(&mut self) -> _BURSTENW {
-                _BURSTENW { w: self }
-            }
-            #[doc = "Bit 6 - FACCEN"]
-            #[inline]
-            pub fn faccen(&mut self) -> _FACCENW {
-                _FACCENW { w: self }
-            }
-            #[doc = "Bits 4:5 - MWID"]
-            #[inline]
-            pub fn mwid(&mut self) -> _MWIDW {
-                _MWIDW { w: self }
-            }
-            #[doc = "Bits 2:3 - MTYP"]
-            #[inline]
-            pub fn mtyp(&mut self) -> _MTYPW {
-                _MTYPW { w: self }
-            }
-            #[doc = "Bit 1 - MUXEN"]
-            #[inline]
-            pub fn muxen(&mut self) -> _MUXENW {
-                _MUXENW { w: self }
-            }
-            #[doc = "Bit 0 - MBKEN"]
-            #[inline]
-            pub fn mbken(&mut self) -> _MBKENW {
-                _MBKENW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash chip-select timing register 2"]
-    pub struct BTR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select timing register 2"]
-    pub mod btr2 {
-        #[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::BTR2 {
-            #[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 = r" Value of the field"]
-        pub struct ACCMODR {
-            bits: u8,
-        }
-        impl ACCMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATLATR {
-            bits: u8,
-        }
-        impl DATLATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BUSTURNR {
-            bits: u8,
-        }
-        impl BUSTURNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATASTR {
-            bits: u8,
-        }
-        impl DATASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDHLDR {
-            bits: u8,
-        }
-        impl ADDHLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDSETR {
-            bits: u8,
-        }
-        impl ADDSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACCMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACCMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATLATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLATW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BUSTURNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BUSTURNW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATASTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDHLDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDHLDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&self) -> ACCMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ACCMODR { bits }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&self) -> DATLATR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLATR { bits }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-            #[doc = "Bits 16:19 - BUSTURN"]
-            #[inline]
-            pub fn busturn(&self) -> BUSTURNR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BUSTURNR { bits }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&self) -> DATASTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATASTR { bits }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&self) -> ADDHLDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDHLDR { bits }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&self) -> ADDSETR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDSETR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xffff_ffff }
-            }
-            #[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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&mut self) -> _ACCMODW {
-                _ACCMODW { w: self }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&mut self) -> _DATLATW {
-                _DATLATW { w: self }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-            #[doc = "Bits 16:19 - BUSTURN"]
-            #[inline]
-            pub fn busturn(&mut self) -> _BUSTURNW {
-                _BUSTURNW { w: self }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&mut self) -> _DATASTW {
-                _DATASTW { w: self }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&mut self) -> _ADDHLDW {
-                _ADDHLDW { w: self }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&mut self) -> _ADDSETW {
-                _ADDSETW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash chip-select control register 3"]
-    pub struct BCR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select control register 3"]
-    pub mod bcr3 {
-        #[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::BCR3 {
-            #[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 = r" Value of the field"]
-        pub struct CBURSTRWR {
-            bits: bool,
-        }
-        impl CBURSTRWR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ASYNCWAITR {
-            bits: bool,
-        }
-        impl ASYNCWAITR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EXTMODR {
-            bits: bool,
-        }
-        impl EXTMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITENR {
-            bits: bool,
-        }
-        impl WAITENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WRENR {
-            bits: bool,
-        }
-        impl WRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITCFGR {
-            bits: bool,
-        }
-        impl WAITCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WRAPMODR {
-            bits: bool,
-        }
-        impl WRAPMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITPOLR {
-            bits: bool,
-        }
-        impl WAITPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BURSTENR {
-            bits: bool,
-        }
-        impl BURSTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACCENR {
-            bits: bool,
-        }
-        impl FACCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MWIDR {
-            bits: u8,
-        }
-        impl MWIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MTYPR {
-            bits: u8,
-        }
-        impl MTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MUXENR {
-            bits: bool,
-        }
-        impl MUXENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MBKENR {
-            bits: bool,
-        }
-        impl MBKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CBURSTRWW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CBURSTRWW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ASYNCWAITW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ASYNCWAITW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EXTMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WRAPMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WRAPMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BURSTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BURSTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MWIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MWIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MUXENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUXENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MBKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBKENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 19 - CBURSTRW"]
-            #[inline]
-            pub fn cburstrw(&self) -> CBURSTRWR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CBURSTRWR { bits }
-            }
-            #[doc = "Bit 15 - ASYNCWAIT"]
-            #[inline]
-            pub fn asyncwait(&self) -> ASYNCWAITR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ASYNCWAITR { bits }
-            }
-            #[doc = "Bit 14 - EXTMOD"]
-            #[inline]
-            pub fn extmod(&self) -> EXTMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EXTMODR { bits }
-            }
-            #[doc = "Bit 13 - WAITEN"]
-            #[inline]
-            pub fn waiten(&self) -> WAITENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITENR { bits }
-            }
-            #[doc = "Bit 12 - WREN"]
-            #[inline]
-            pub fn wren(&self) -> WRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRENR { bits }
-            }
-            #[doc = "Bit 11 - WAITCFG"]
-            #[inline]
-            pub fn waitcfg(&self) -> WAITCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITCFGR { bits }
-            }
-            #[doc = "Bit 10 - WRAPMOD"]
-            #[inline]
-            pub fn wrapmod(&self) -> WRAPMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRAPMODR { bits }
-            }
-            #[doc = "Bit 9 - WAITPOL"]
-            #[inline]
-            pub fn waitpol(&self) -> WAITPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITPOLR { bits }
-            }
-            #[doc = "Bit 8 - BURSTEN"]
-            #[inline]
-            pub fn bursten(&self) -> BURSTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BURSTENR { bits }
-            }
-            #[doc = "Bit 6 - FACCEN"]
-            #[inline]
-            pub fn faccen(&self) -> FACCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACCENR { bits }
-            }
-            #[doc = "Bits 4:5 - MWID"]
-            #[inline]
-            pub fn mwid(&self) -> MWIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MWIDR { bits }
-            }
-            #[doc = "Bits 2:3 - MTYP"]
-            #[inline]
-            pub fn mtyp(&self) -> MTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MTYPR { bits }
-            }
-            #[doc = "Bit 1 - MUXEN"]
-            #[inline]
-            pub fn muxen(&self) -> MUXENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUXENR { bits }
-            }
-            #[doc = "Bit 0 - MBKEN"]
-            #[inline]
-            pub fn mbken(&self) -> MBKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MBKENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x30d0 }
-            }
-            #[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 19 - CBURSTRW"]
-            #[inline]
-            pub fn cburstrw(&mut self) -> _CBURSTRWW {
-                _CBURSTRWW { w: self }
-            }
-            #[doc = "Bit 15 - ASYNCWAIT"]
-            #[inline]
-            pub fn asyncwait(&mut self) -> _ASYNCWAITW {
-                _ASYNCWAITW { w: self }
-            }
-            #[doc = "Bit 14 - EXTMOD"]
-            #[inline]
-            pub fn extmod(&mut self) -> _EXTMODW {
-                _EXTMODW { w: self }
-            }
-            #[doc = "Bit 13 - WAITEN"]
-            #[inline]
-            pub fn waiten(&mut self) -> _WAITENW {
-                _WAITENW { w: self }
-            }
-            #[doc = "Bit 12 - WREN"]
-            #[inline]
-            pub fn wren(&mut self) -> _WRENW {
-                _WRENW { w: self }
-            }
-            #[doc = "Bit 11 - WAITCFG"]
-            #[inline]
-            pub fn waitcfg(&mut self) -> _WAITCFGW {
-                _WAITCFGW { w: self }
-            }
-            #[doc = "Bit 10 - WRAPMOD"]
-            #[inline]
-            pub fn wrapmod(&mut self) -> _WRAPMODW {
-                _WRAPMODW { w: self }
-            }
-            #[doc = "Bit 9 - WAITPOL"]
-            #[inline]
-            pub fn waitpol(&mut self) -> _WAITPOLW {
-                _WAITPOLW { w: self }
-            }
-            #[doc = "Bit 8 - BURSTEN"]
-            #[inline]
-            pub fn bursten(&mut self) -> _BURSTENW {
-                _BURSTENW { w: self }
-            }
-            #[doc = "Bit 6 - FACCEN"]
-            #[inline]
-            pub fn faccen(&mut self) -> _FACCENW {
-                _FACCENW { w: self }
-            }
-            #[doc = "Bits 4:5 - MWID"]
-            #[inline]
-            pub fn mwid(&mut self) -> _MWIDW {
-                _MWIDW { w: self }
-            }
-            #[doc = "Bits 2:3 - MTYP"]
-            #[inline]
-            pub fn mtyp(&mut self) -> _MTYPW {
-                _MTYPW { w: self }
-            }
-            #[doc = "Bit 1 - MUXEN"]
-            #[inline]
-            pub fn muxen(&mut self) -> _MUXENW {
-                _MUXENW { w: self }
-            }
-            #[doc = "Bit 0 - MBKEN"]
-            #[inline]
-            pub fn mbken(&mut self) -> _MBKENW {
-                _MBKENW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash chip-select timing register 3"]
-    pub struct BTR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select timing register 3"]
-    pub mod btr3 {
-        #[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::BTR3 {
-            #[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 = r" Value of the field"]
-        pub struct ACCMODR {
-            bits: u8,
-        }
-        impl ACCMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATLATR {
-            bits: u8,
-        }
-        impl DATLATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BUSTURNR {
-            bits: u8,
-        }
-        impl BUSTURNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATASTR {
-            bits: u8,
-        }
-        impl DATASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDHLDR {
-            bits: u8,
-        }
-        impl ADDHLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDSETR {
-            bits: u8,
-        }
-        impl ADDSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACCMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACCMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATLATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLATW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BUSTURNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BUSTURNW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATASTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDHLDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDHLDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&self) -> ACCMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ACCMODR { bits }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&self) -> DATLATR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLATR { bits }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-            #[doc = "Bits 16:19 - BUSTURN"]
-            #[inline]
-            pub fn busturn(&self) -> BUSTURNR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BUSTURNR { bits }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&self) -> DATASTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATASTR { bits }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&self) -> ADDHLDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDHLDR { bits }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&self) -> ADDSETR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDSETR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xffff_ffff }
-            }
-            #[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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&mut self) -> _ACCMODW {
-                _ACCMODW { w: self }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&mut self) -> _DATLATW {
-                _DATLATW { w: self }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-            #[doc = "Bits 16:19 - BUSTURN"]
-            #[inline]
-            pub fn busturn(&mut self) -> _BUSTURNW {
-                _BUSTURNW { w: self }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&mut self) -> _DATASTW {
-                _DATASTW { w: self }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&mut self) -> _ADDHLDW {
-                _ADDHLDW { w: self }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&mut self) -> _ADDSETW {
-                _ADDSETW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash chip-select control register 4"]
-    pub struct BCR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select control register 4"]
-    pub mod bcr4 {
-        #[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::BCR4 {
-            #[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 = r" Value of the field"]
-        pub struct CBURSTRWR {
-            bits: bool,
-        }
-        impl CBURSTRWR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ASYNCWAITR {
-            bits: bool,
-        }
-        impl ASYNCWAITR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EXTMODR {
-            bits: bool,
-        }
-        impl EXTMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITENR {
-            bits: bool,
-        }
-        impl WAITENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WRENR {
-            bits: bool,
-        }
-        impl WRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITCFGR {
-            bits: bool,
-        }
-        impl WAITCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WRAPMODR {
-            bits: bool,
-        }
-        impl WRAPMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAITPOLR {
-            bits: bool,
-        }
-        impl WAITPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BURSTENR {
-            bits: bool,
-        }
-        impl BURSTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FACCENR {
-            bits: bool,
-        }
-        impl FACCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MWIDR {
-            bits: u8,
-        }
-        impl MWIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MTYPR {
-            bits: u8,
-        }
-        impl MTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MUXENR {
-            bits: bool,
-        }
-        impl MUXENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MBKENR {
-            bits: bool,
-        }
-        impl MBKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CBURSTRWW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CBURSTRWW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ASYNCWAITW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ASYNCWAITW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EXTMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WRAPMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WRAPMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAITPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAITPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BURSTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BURSTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FACCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FACCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MWIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MWIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MUXENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUXENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MBKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MBKENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 19 - CBURSTRW"]
-            #[inline]
-            pub fn cburstrw(&self) -> CBURSTRWR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CBURSTRWR { bits }
-            }
-            #[doc = "Bit 15 - ASYNCWAIT"]
-            #[inline]
-            pub fn asyncwait(&self) -> ASYNCWAITR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ASYNCWAITR { bits }
-            }
-            #[doc = "Bit 14 - EXTMOD"]
-            #[inline]
-            pub fn extmod(&self) -> EXTMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EXTMODR { bits }
-            }
-            #[doc = "Bit 13 - WAITEN"]
-            #[inline]
-            pub fn waiten(&self) -> WAITENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITENR { bits }
-            }
-            #[doc = "Bit 12 - WREN"]
-            #[inline]
-            pub fn wren(&self) -> WRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRENR { bits }
-            }
-            #[doc = "Bit 11 - WAITCFG"]
-            #[inline]
-            pub fn waitcfg(&self) -> WAITCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITCFGR { bits }
-            }
-            #[doc = "Bit 10 - WRAPMOD"]
-            #[inline]
-            pub fn wrapmod(&self) -> WRAPMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRAPMODR { bits }
-            }
-            #[doc = "Bit 9 - WAITPOL"]
-            #[inline]
-            pub fn waitpol(&self) -> WAITPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAITPOLR { bits }
-            }
-            #[doc = "Bit 8 - BURSTEN"]
-            #[inline]
-            pub fn bursten(&self) -> BURSTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BURSTENR { bits }
-            }
-            #[doc = "Bit 6 - FACCEN"]
-            #[inline]
-            pub fn faccen(&self) -> FACCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FACCENR { bits }
-            }
-            #[doc = "Bits 4:5 - MWID"]
-            #[inline]
-            pub fn mwid(&self) -> MWIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MWIDR { bits }
-            }
-            #[doc = "Bits 2:3 - MTYP"]
-            #[inline]
-            pub fn mtyp(&self) -> MTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MTYPR { bits }
-            }
-            #[doc = "Bit 1 - MUXEN"]
-            #[inline]
-            pub fn muxen(&self) -> MUXENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUXENR { bits }
-            }
-            #[doc = "Bit 0 - MBKEN"]
-            #[inline]
-            pub fn mbken(&self) -> MBKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MBKENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x30d0 }
-            }
-            #[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 19 - CBURSTRW"]
-            #[inline]
-            pub fn cburstrw(&mut self) -> _CBURSTRWW {
-                _CBURSTRWW { w: self }
-            }
-            #[doc = "Bit 15 - ASYNCWAIT"]
-            #[inline]
-            pub fn asyncwait(&mut self) -> _ASYNCWAITW {
-                _ASYNCWAITW { w: self }
-            }
-            #[doc = "Bit 14 - EXTMOD"]
-            #[inline]
-            pub fn extmod(&mut self) -> _EXTMODW {
-                _EXTMODW { w: self }
-            }
-            #[doc = "Bit 13 - WAITEN"]
-            #[inline]
-            pub fn waiten(&mut self) -> _WAITENW {
-                _WAITENW { w: self }
-            }
-            #[doc = "Bit 12 - WREN"]
-            #[inline]
-            pub fn wren(&mut self) -> _WRENW {
-                _WRENW { w: self }
-            }
-            #[doc = "Bit 11 - WAITCFG"]
-            #[inline]
-            pub fn waitcfg(&mut self) -> _WAITCFGW {
-                _WAITCFGW { w: self }
-            }
-            #[doc = "Bit 10 - WRAPMOD"]
-            #[inline]
-            pub fn wrapmod(&mut self) -> _WRAPMODW {
-                _WRAPMODW { w: self }
-            }
-            #[doc = "Bit 9 - WAITPOL"]
-            #[inline]
-            pub fn waitpol(&mut self) -> _WAITPOLW {
-                _WAITPOLW { w: self }
-            }
-            #[doc = "Bit 8 - BURSTEN"]
-            #[inline]
-            pub fn bursten(&mut self) -> _BURSTENW {
-                _BURSTENW { w: self }
-            }
-            #[doc = "Bit 6 - FACCEN"]
-            #[inline]
-            pub fn faccen(&mut self) -> _FACCENW {
-                _FACCENW { w: self }
-            }
-            #[doc = "Bits 4:5 - MWID"]
-            #[inline]
-            pub fn mwid(&mut self) -> _MWIDW {
-                _MWIDW { w: self }
-            }
-            #[doc = "Bits 2:3 - MTYP"]
-            #[inline]
-            pub fn mtyp(&mut self) -> _MTYPW {
-                _MTYPW { w: self }
-            }
-            #[doc = "Bit 1 - MUXEN"]
-            #[inline]
-            pub fn muxen(&mut self) -> _MUXENW {
-                _MUXENW { w: self }
-            }
-            #[doc = "Bit 0 - MBKEN"]
-            #[inline]
-            pub fn mbken(&mut self) -> _MBKENW {
-                _MBKENW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash chip-select timing register 4"]
-    pub struct BTR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash chip-select timing register 4"]
-    pub mod btr4 {
-        #[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::BTR4 {
-            #[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 = r" Value of the field"]
-        pub struct ACCMODR {
-            bits: u8,
-        }
-        impl ACCMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATLATR {
-            bits: u8,
-        }
-        impl DATLATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BUSTURNR {
-            bits: u8,
-        }
-        impl BUSTURNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATASTR {
-            bits: u8,
-        }
-        impl DATASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDHLDR {
-            bits: u8,
-        }
-        impl ADDHLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDSETR {
-            bits: u8,
-        }
-        impl ADDSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACCMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACCMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATLATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLATW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _BUSTURNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BUSTURNW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATASTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDHLDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDHLDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&self) -> ACCMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ACCMODR { bits }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&self) -> DATLATR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLATR { bits }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-            #[doc = "Bits 16:19 - BUSTURN"]
-            #[inline]
-            pub fn busturn(&self) -> BUSTURNR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                BUSTURNR { bits }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&self) -> DATASTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATASTR { bits }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&self) -> ADDHLDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDHLDR { bits }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&self) -> ADDSETR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDSETR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xffff_ffff }
-            }
-            #[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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&mut self) -> _ACCMODW {
-                _ACCMODW { w: self }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&mut self) -> _DATLATW {
-                _DATLATW { w: self }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-            #[doc = "Bits 16:19 - BUSTURN"]
-            #[inline]
-            pub fn busturn(&mut self) -> _BUSTURNW {
-                _BUSTURNW { w: self }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&mut self) -> _DATASTW {
-                _DATASTW { w: self }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&mut self) -> _ADDHLDW {
-                _ADDHLDW { w: self }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&mut self) -> _ADDSETW {
-                _ADDSETW { w: self }
-            }
-        }
-    }
-    #[doc = "PC Card/NAND Flash control register 2"]
-    pub struct PCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "PC Card/NAND Flash control register 2"]
-    pub mod pcr2 {
-        #[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::PCR2 {
-            #[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 = r" Value of the field"]
-        pub struct ECCPSR {
-            bits: u8,
-        }
-        impl ECCPSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TARR {
-            bits: u8,
-        }
-        impl TARR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TCLRR {
-            bits: u8,
-        }
-        impl TCLRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ECCENR {
-            bits: bool,
-        }
-        impl ECCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWIDR {
-            bits: u8,
-        }
-        impl PWIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PTYPR {
-            bits: bool,
-        }
-        impl PTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PBKENR {
-            bits: bool,
-        }
-        impl PBKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWAITENR {
-            bits: bool,
-        }
-        impl PWAITENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ECCPSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECCPSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 17;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TARW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TARW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TCLRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCLRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 9;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ECCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTYPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PBKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWAITENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWAITENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 17:19 - ECCPS"]
-            #[inline]
-            pub fn eccps(&self) -> ECCPSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ECCPSR { bits }
-            }
-            #[doc = "Bits 13:16 - TAR"]
-            #[inline]
-            pub fn tar(&self) -> TARR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TARR { bits }
-            }
-            #[doc = "Bits 9:12 - TCLR"]
-            #[inline]
-            pub fn tclr(&self) -> TCLRR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TCLRR { bits }
-            }
-            #[doc = "Bit 6 - ECCEN"]
-            #[inline]
-            pub fn eccen(&self) -> ECCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ECCENR { bits }
-            }
-            #[doc = "Bits 4:5 - PWID"]
-            #[inline]
-            pub fn pwid(&self) -> PWIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PWIDR { bits }
-            }
-            #[doc = "Bit 3 - PTYP"]
-            #[inline]
-            pub fn ptyp(&self) -> PTYPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PTYPR { bits }
-            }
-            #[doc = "Bit 2 - PBKEN"]
-            #[inline]
-            pub fn pbken(&self) -> PBKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PBKENR { bits }
-            }
-            #[doc = "Bit 1 - PWAITEN"]
-            #[inline]
-            pub fn pwaiten(&self) -> PWAITENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PWAITENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x18 }
-            }
-            #[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 17:19 - ECCPS"]
-            #[inline]
-            pub fn eccps(&mut self) -> _ECCPSW {
-                _ECCPSW { w: self }
-            }
-            #[doc = "Bits 13:16 - TAR"]
-            #[inline]
-            pub fn tar(&mut self) -> _TARW {
-                _TARW { w: self }
-            }
-            #[doc = "Bits 9:12 - TCLR"]
-            #[inline]
-            pub fn tclr(&mut self) -> _TCLRW {
-                _TCLRW { w: self }
-            }
-            #[doc = "Bit 6 - ECCEN"]
-            #[inline]
-            pub fn eccen(&mut self) -> _ECCENW {
-                _ECCENW { w: self }
-            }
-            #[doc = "Bits 4:5 - PWID"]
-            #[inline]
-            pub fn pwid(&mut self) -> _PWIDW {
-                _PWIDW { w: self }
-            }
-            #[doc = "Bit 3 - PTYP"]
-            #[inline]
-            pub fn ptyp(&mut self) -> _PTYPW {
-                _PTYPW { w: self }
-            }
-            #[doc = "Bit 2 - PBKEN"]
-            #[inline]
-            pub fn pbken(&mut self) -> _PBKENW {
-                _PBKENW { w: self }
-            }
-            #[doc = "Bit 1 - PWAITEN"]
-            #[inline]
-            pub fn pwaiten(&mut self) -> _PWAITENW {
-                _PWAITENW { w: self }
-            }
-        }
-    }
-    #[doc = "FIFO status and interrupt register 2"]
-    pub struct SR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "FIFO status and interrupt register 2"]
-    pub mod sr2 {
-        #[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::SR2 {
-            #[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 = r" Value of the field"]
-        pub struct FEMPTR {
-            bits: bool,
-        }
-        impl FEMPTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IFENR {
-            bits: bool,
-        }
-        impl IFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ILENR {
-            bits: bool,
-        }
-        impl ILENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IRENR {
-            bits: bool,
-        }
-        impl IRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IFSR {
-            bits: bool,
-        }
-        impl IFSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ILSR {
-            bits: bool,
-        }
-        impl ILSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IRSR {
-            bits: bool,
-        }
-        impl IRSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _IFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IFENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ILENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ILENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IFSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IFSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ILSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ILSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IRSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IRSW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - FEMPT"]
-            #[inline]
-            pub fn fempt(&self) -> FEMPTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEMPTR { bits }
-            }
-            #[doc = "Bit 5 - IFEN"]
-            #[inline]
-            pub fn ifen(&self) -> IFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IFENR { bits }
-            }
-            #[doc = "Bit 4 - ILEN"]
-            #[inline]
-            pub fn ilen(&self) -> ILENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ILENR { bits }
-            }
-            #[doc = "Bit 3 - IREN"]
-            #[inline]
-            pub fn iren(&self) -> IRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IRENR { bits }
-            }
-            #[doc = "Bit 2 - IFS"]
-            #[inline]
-            pub fn ifs(&self) -> IFSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IFSR { bits }
-            }
-            #[doc = "Bit 1 - ILS"]
-            #[inline]
-            pub fn ils(&self) -> ILSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ILSR { bits }
-            }
-            #[doc = "Bit 0 - IRS"]
-            #[inline]
-            pub fn irs(&self) -> IRSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IRSR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x40 }
-            }
-            #[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 5 - IFEN"]
-            #[inline]
-            pub fn ifen(&mut self) -> _IFENW {
-                _IFENW { w: self }
-            }
-            #[doc = "Bit 4 - ILEN"]
-            #[inline]
-            pub fn ilen(&mut self) -> _ILENW {
-                _ILENW { w: self }
-            }
-            #[doc = "Bit 3 - IREN"]
-            #[inline]
-            pub fn iren(&mut self) -> _IRENW {
-                _IRENW { w: self }
-            }
-            #[doc = "Bit 2 - IFS"]
-            #[inline]
-            pub fn ifs(&mut self) -> _IFSW {
-                _IFSW { w: self }
-            }
-            #[doc = "Bit 1 - ILS"]
-            #[inline]
-            pub fn ils(&mut self) -> _ILSW {
-                _ILSW { w: self }
-            }
-            #[doc = "Bit 0 - IRS"]
-            #[inline]
-            pub fn irs(&mut self) -> _IRSW {
-                _IRSW { w: self }
-            }
-        }
-    }
-    #[doc = "Common memory space timing register 2"]
-    pub struct PMEM2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Common memory space timing register 2"]
-    pub mod pmem2 {
-        #[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::PMEM2 {
-            #[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 = r" Value of the field"]
-        pub struct MEMHIZXR {
-            bits: u8,
-        }
-        impl MEMHIZXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMHOLDXR {
-            bits: u8,
-        }
-        impl MEMHOLDXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMWAITXR {
-            bits: u8,
-        }
-        impl MEMWAITXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMSETXR {
-            bits: u8,
-        }
-        impl MEMSETXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMHIZXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMHIZXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMHOLDXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMHOLDXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMWAITXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMWAITXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMSETXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMSETXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - MEMHIZx"]
-            #[inline]
-            pub fn memhizx(&self) -> MEMHIZXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMHIZXR { bits }
-            }
-            #[doc = "Bits 16:23 - MEMHOLDx"]
-            #[inline]
-            pub fn memholdx(&self) -> MEMHOLDXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMHOLDXR { bits }
-            }
-            #[doc = "Bits 8:15 - MEMWAITx"]
-            #[inline]
-            pub fn memwaitx(&self) -> MEMWAITXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMWAITXR { bits }
-            }
-            #[doc = "Bits 0:7 - MEMSETx"]
-            #[inline]
-            pub fn memsetx(&self) -> MEMSETXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMSETXR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xfcfc_fcfc }
-            }
-            #[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 24:31 - MEMHIZx"]
-            #[inline]
-            pub fn memhizx(&mut self) -> _MEMHIZXW {
-                _MEMHIZXW { w: self }
-            }
-            #[doc = "Bits 16:23 - MEMHOLDx"]
-            #[inline]
-            pub fn memholdx(&mut self) -> _MEMHOLDXW {
-                _MEMHOLDXW { w: self }
-            }
-            #[doc = "Bits 8:15 - MEMWAITx"]
-            #[inline]
-            pub fn memwaitx(&mut self) -> _MEMWAITXW {
-                _MEMWAITXW { w: self }
-            }
-            #[doc = "Bits 0:7 - MEMSETx"]
-            #[inline]
-            pub fn memsetx(&mut self) -> _MEMSETXW {
-                _MEMSETXW { w: self }
-            }
-        }
-    }
-    #[doc = "Attribute memory space timing register 2"]
-    pub struct PATT2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Attribute memory space timing register 2"]
-    pub mod patt2 {
-        #[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::PATT2 {
-            #[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 = r" Value of the field"]
-        pub struct ATTHIZXR {
-            bits: u8,
-        }
-        impl ATTHIZXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTHOLDXR {
-            bits: u8,
-        }
-        impl ATTHOLDXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTWAITXR {
-            bits: u8,
-        }
-        impl ATTWAITXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTSETXR {
-            bits: u8,
-        }
-        impl ATTSETXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTHIZXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTHIZXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTHOLDXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTHOLDXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTWAITXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTWAITXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTSETXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTSETXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - ATTHIZx"]
-            #[inline]
-            pub fn atthizx(&self) -> ATTHIZXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTHIZXR { bits }
-            }
-            #[doc = "Bits 16:23 - ATTHOLDx"]
-            #[inline]
-            pub fn attholdx(&self) -> ATTHOLDXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTHOLDXR { bits }
-            }
-            #[doc = "Bits 8:15 - ATTWAITx"]
-            #[inline]
-            pub fn attwaitx(&self) -> ATTWAITXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTWAITXR { bits }
-            }
-            #[doc = "Bits 0:7 - ATTSETx"]
-            #[inline]
-            pub fn attsetx(&self) -> ATTSETXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTSETXR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xfcfc_fcfc }
-            }
-            #[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 24:31 - ATTHIZx"]
-            #[inline]
-            pub fn atthizx(&mut self) -> _ATTHIZXW {
-                _ATTHIZXW { w: self }
-            }
-            #[doc = "Bits 16:23 - ATTHOLDx"]
-            #[inline]
-            pub fn attholdx(&mut self) -> _ATTHOLDXW {
-                _ATTHOLDXW { w: self }
-            }
-            #[doc = "Bits 8:15 - ATTWAITx"]
-            #[inline]
-            pub fn attwaitx(&mut self) -> _ATTWAITXW {
-                _ATTWAITXW { w: self }
-            }
-            #[doc = "Bits 0:7 - ATTSETx"]
-            #[inline]
-            pub fn attsetx(&mut self) -> _ATTSETXW {
-                _ATTSETXW { w: self }
-            }
-        }
-    }
-    #[doc = "ECC result register 2"]
-    pub struct ECCR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "ECC result register 2"]
-    pub mod eccr2 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::ECCR2 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ECCXR {
-            bits: u32,
-        }
-        impl ECCXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:31 - ECCx"]
-            #[inline]
-            pub fn eccx(&self) -> ECCXR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                ECCXR { bits }
-            }
-        }
-    }
-    #[doc = "PC Card/NAND Flash control register 3"]
-    pub struct PCR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "PC Card/NAND Flash control register 3"]
-    pub mod pcr3 {
-        #[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::PCR3 {
-            #[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 = r" Value of the field"]
-        pub struct ECCPSR {
-            bits: u8,
-        }
-        impl ECCPSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TARR {
-            bits: u8,
-        }
-        impl TARR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TCLRR {
-            bits: u8,
-        }
-        impl TCLRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ECCENR {
-            bits: bool,
-        }
-        impl ECCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWIDR {
-            bits: u8,
-        }
-        impl PWIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PTYPR {
-            bits: bool,
-        }
-        impl PTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PBKENR {
-            bits: bool,
-        }
-        impl PBKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWAITENR {
-            bits: bool,
-        }
-        impl PWAITENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ECCPSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECCPSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 17;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TARW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TARW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TCLRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCLRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 9;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ECCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTYPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PBKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWAITENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWAITENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 17:19 - ECCPS"]
-            #[inline]
-            pub fn eccps(&self) -> ECCPSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ECCPSR { bits }
-            }
-            #[doc = "Bits 13:16 - TAR"]
-            #[inline]
-            pub fn tar(&self) -> TARR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TARR { bits }
-            }
-            #[doc = "Bits 9:12 - TCLR"]
-            #[inline]
-            pub fn tclr(&self) -> TCLRR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TCLRR { bits }
-            }
-            #[doc = "Bit 6 - ECCEN"]
-            #[inline]
-            pub fn eccen(&self) -> ECCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ECCENR { bits }
-            }
-            #[doc = "Bits 4:5 - PWID"]
-            #[inline]
-            pub fn pwid(&self) -> PWIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PWIDR { bits }
-            }
-            #[doc = "Bit 3 - PTYP"]
-            #[inline]
-            pub fn ptyp(&self) -> PTYPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PTYPR { bits }
-            }
-            #[doc = "Bit 2 - PBKEN"]
-            #[inline]
-            pub fn pbken(&self) -> PBKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PBKENR { bits }
-            }
-            #[doc = "Bit 1 - PWAITEN"]
-            #[inline]
-            pub fn pwaiten(&self) -> PWAITENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PWAITENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x18 }
-            }
-            #[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 17:19 - ECCPS"]
-            #[inline]
-            pub fn eccps(&mut self) -> _ECCPSW {
-                _ECCPSW { w: self }
-            }
-            #[doc = "Bits 13:16 - TAR"]
-            #[inline]
-            pub fn tar(&mut self) -> _TARW {
-                _TARW { w: self }
-            }
-            #[doc = "Bits 9:12 - TCLR"]
-            #[inline]
-            pub fn tclr(&mut self) -> _TCLRW {
-                _TCLRW { w: self }
-            }
-            #[doc = "Bit 6 - ECCEN"]
-            #[inline]
-            pub fn eccen(&mut self) -> _ECCENW {
-                _ECCENW { w: self }
-            }
-            #[doc = "Bits 4:5 - PWID"]
-            #[inline]
-            pub fn pwid(&mut self) -> _PWIDW {
-                _PWIDW { w: self }
-            }
-            #[doc = "Bit 3 - PTYP"]
-            #[inline]
-            pub fn ptyp(&mut self) -> _PTYPW {
-                _PTYPW { w: self }
-            }
-            #[doc = "Bit 2 - PBKEN"]
-            #[inline]
-            pub fn pbken(&mut self) -> _PBKENW {
-                _PBKENW { w: self }
-            }
-            #[doc = "Bit 1 - PWAITEN"]
-            #[inline]
-            pub fn pwaiten(&mut self) -> _PWAITENW {
-                _PWAITENW { w: self }
-            }
-        }
-    }
-    #[doc = "FIFO status and interrupt register 3"]
-    pub struct SR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "FIFO status and interrupt register 3"]
-    pub mod sr3 {
-        #[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::SR3 {
-            #[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 = r" Value of the field"]
-        pub struct FEMPTR {
-            bits: bool,
-        }
-        impl FEMPTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IFENR {
-            bits: bool,
-        }
-        impl IFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ILENR {
-            bits: bool,
-        }
-        impl ILENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IRENR {
-            bits: bool,
-        }
-        impl IRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IFSR {
-            bits: bool,
-        }
-        impl IFSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ILSR {
-            bits: bool,
-        }
-        impl ILSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IRSR {
-            bits: bool,
-        }
-        impl IRSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _IFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IFENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ILENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ILENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IFSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IFSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ILSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ILSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IRSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IRSW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - FEMPT"]
-            #[inline]
-            pub fn fempt(&self) -> FEMPTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEMPTR { bits }
-            }
-            #[doc = "Bit 5 - IFEN"]
-            #[inline]
-            pub fn ifen(&self) -> IFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IFENR { bits }
-            }
-            #[doc = "Bit 4 - ILEN"]
-            #[inline]
-            pub fn ilen(&self) -> ILENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ILENR { bits }
-            }
-            #[doc = "Bit 3 - IREN"]
-            #[inline]
-            pub fn iren(&self) -> IRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IRENR { bits }
-            }
-            #[doc = "Bit 2 - IFS"]
-            #[inline]
-            pub fn ifs(&self) -> IFSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IFSR { bits }
-            }
-            #[doc = "Bit 1 - ILS"]
-            #[inline]
-            pub fn ils(&self) -> ILSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ILSR { bits }
-            }
-            #[doc = "Bit 0 - IRS"]
-            #[inline]
-            pub fn irs(&self) -> IRSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IRSR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x40 }
-            }
-            #[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 5 - IFEN"]
-            #[inline]
-            pub fn ifen(&mut self) -> _IFENW {
-                _IFENW { w: self }
-            }
-            #[doc = "Bit 4 - ILEN"]
-            #[inline]
-            pub fn ilen(&mut self) -> _ILENW {
-                _ILENW { w: self }
-            }
-            #[doc = "Bit 3 - IREN"]
-            #[inline]
-            pub fn iren(&mut self) -> _IRENW {
-                _IRENW { w: self }
-            }
-            #[doc = "Bit 2 - IFS"]
-            #[inline]
-            pub fn ifs(&mut self) -> _IFSW {
-                _IFSW { w: self }
-            }
-            #[doc = "Bit 1 - ILS"]
-            #[inline]
-            pub fn ils(&mut self) -> _ILSW {
-                _ILSW { w: self }
-            }
-            #[doc = "Bit 0 - IRS"]
-            #[inline]
-            pub fn irs(&mut self) -> _IRSW {
-                _IRSW { w: self }
-            }
-        }
-    }
-    #[doc = "Common memory space timing register 3"]
-    pub struct PMEM3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Common memory space timing register 3"]
-    pub mod pmem3 {
-        #[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::PMEM3 {
-            #[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 = r" Value of the field"]
-        pub struct MEMHIZXR {
-            bits: u8,
-        }
-        impl MEMHIZXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMHOLDXR {
-            bits: u8,
-        }
-        impl MEMHOLDXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMWAITXR {
-            bits: u8,
-        }
-        impl MEMWAITXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMSETXR {
-            bits: u8,
-        }
-        impl MEMSETXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMHIZXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMHIZXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMHOLDXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMHOLDXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMWAITXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMWAITXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMSETXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMSETXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - MEMHIZx"]
-            #[inline]
-            pub fn memhizx(&self) -> MEMHIZXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMHIZXR { bits }
-            }
-            #[doc = "Bits 16:23 - MEMHOLDx"]
-            #[inline]
-            pub fn memholdx(&self) -> MEMHOLDXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMHOLDXR { bits }
-            }
-            #[doc = "Bits 8:15 - MEMWAITx"]
-            #[inline]
-            pub fn memwaitx(&self) -> MEMWAITXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMWAITXR { bits }
-            }
-            #[doc = "Bits 0:7 - MEMSETx"]
-            #[inline]
-            pub fn memsetx(&self) -> MEMSETXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMSETXR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xfcfc_fcfc }
-            }
-            #[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 24:31 - MEMHIZx"]
-            #[inline]
-            pub fn memhizx(&mut self) -> _MEMHIZXW {
-                _MEMHIZXW { w: self }
-            }
-            #[doc = "Bits 16:23 - MEMHOLDx"]
-            #[inline]
-            pub fn memholdx(&mut self) -> _MEMHOLDXW {
-                _MEMHOLDXW { w: self }
-            }
-            #[doc = "Bits 8:15 - MEMWAITx"]
-            #[inline]
-            pub fn memwaitx(&mut self) -> _MEMWAITXW {
-                _MEMWAITXW { w: self }
-            }
-            #[doc = "Bits 0:7 - MEMSETx"]
-            #[inline]
-            pub fn memsetx(&mut self) -> _MEMSETXW {
-                _MEMSETXW { w: self }
-            }
-        }
-    }
-    #[doc = "Attribute memory space timing register 3"]
-    pub struct PATT3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Attribute memory space timing register 3"]
-    pub mod patt3 {
-        #[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::PATT3 {
-            #[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 = r" Value of the field"]
-        pub struct ATTHIZXR {
-            bits: u8,
-        }
-        impl ATTHIZXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTHOLDXR {
-            bits: u8,
-        }
-        impl ATTHOLDXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTWAITXR {
-            bits: u8,
-        }
-        impl ATTWAITXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTSETXR {
-            bits: u8,
-        }
-        impl ATTSETXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTHIZXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTHIZXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTHOLDXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTHOLDXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTWAITXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTWAITXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTSETXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTSETXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - ATTHIZx"]
-            #[inline]
-            pub fn atthizx(&self) -> ATTHIZXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTHIZXR { bits }
-            }
-            #[doc = "Bits 16:23 - ATTHOLDx"]
-            #[inline]
-            pub fn attholdx(&self) -> ATTHOLDXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTHOLDXR { bits }
-            }
-            #[doc = "Bits 8:15 - ATTWAITx"]
-            #[inline]
-            pub fn attwaitx(&self) -> ATTWAITXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTWAITXR { bits }
-            }
-            #[doc = "Bits 0:7 - ATTSETx"]
-            #[inline]
-            pub fn attsetx(&self) -> ATTSETXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTSETXR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xfcfc_fcfc }
-            }
-            #[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 24:31 - ATTHIZx"]
-            #[inline]
-            pub fn atthizx(&mut self) -> _ATTHIZXW {
-                _ATTHIZXW { w: self }
-            }
-            #[doc = "Bits 16:23 - ATTHOLDx"]
-            #[inline]
-            pub fn attholdx(&mut self) -> _ATTHOLDXW {
-                _ATTHOLDXW { w: self }
-            }
-            #[doc = "Bits 8:15 - ATTWAITx"]
-            #[inline]
-            pub fn attwaitx(&mut self) -> _ATTWAITXW {
-                _ATTWAITXW { w: self }
-            }
-            #[doc = "Bits 0:7 - ATTSETx"]
-            #[inline]
-            pub fn attsetx(&mut self) -> _ATTSETXW {
-                _ATTSETXW { w: self }
-            }
-        }
-    }
-    #[doc = "ECC result register 3"]
-    pub struct ECCR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "ECC result register 3"]
-    pub mod eccr3 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::ECCR3 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ECCXR {
-            bits: u32,
-        }
-        impl ECCXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:31 - ECCx"]
-            #[inline]
-            pub fn eccx(&self) -> ECCXR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                ECCXR { bits }
-            }
-        }
-    }
-    #[doc = "PC Card/NAND Flash control register 4"]
-    pub struct PCR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "PC Card/NAND Flash control register 4"]
-    pub mod pcr4 {
-        #[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::PCR4 {
-            #[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 = r" Value of the field"]
-        pub struct ECCPSR {
-            bits: u8,
-        }
-        impl ECCPSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TARR {
-            bits: u8,
-        }
-        impl TARR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TCLRR {
-            bits: u8,
-        }
-        impl TCLRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ECCENR {
-            bits: bool,
-        }
-        impl ECCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWIDR {
-            bits: u8,
-        }
-        impl PWIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PTYPR {
-            bits: bool,
-        }
-        impl PTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PBKENR {
-            bits: bool,
-        }
-        impl PBKENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWAITENR {
-            bits: bool,
-        }
-        impl PWAITENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ECCPSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECCPSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 17;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TARW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TARW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TCLRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCLRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 9;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ECCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ECCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTYPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PBKENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PBKENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWAITENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWAITENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 17:19 - ECCPS"]
-            #[inline]
-            pub fn eccps(&self) -> ECCPSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ECCPSR { bits }
-            }
-            #[doc = "Bits 13:16 - TAR"]
-            #[inline]
-            pub fn tar(&self) -> TARR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TARR { bits }
-            }
-            #[doc = "Bits 9:12 - TCLR"]
-            #[inline]
-            pub fn tclr(&self) -> TCLRR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TCLRR { bits }
-            }
-            #[doc = "Bit 6 - ECCEN"]
-            #[inline]
-            pub fn eccen(&self) -> ECCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ECCENR { bits }
-            }
-            #[doc = "Bits 4:5 - PWID"]
-            #[inline]
-            pub fn pwid(&self) -> PWIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PWIDR { bits }
-            }
-            #[doc = "Bit 3 - PTYP"]
-            #[inline]
-            pub fn ptyp(&self) -> PTYPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PTYPR { bits }
-            }
-            #[doc = "Bit 2 - PBKEN"]
-            #[inline]
-            pub fn pbken(&self) -> PBKENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PBKENR { bits }
-            }
-            #[doc = "Bit 1 - PWAITEN"]
-            #[inline]
-            pub fn pwaiten(&self) -> PWAITENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PWAITENR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x18 }
-            }
-            #[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 17:19 - ECCPS"]
-            #[inline]
-            pub fn eccps(&mut self) -> _ECCPSW {
-                _ECCPSW { w: self }
-            }
-            #[doc = "Bits 13:16 - TAR"]
-            #[inline]
-            pub fn tar(&mut self) -> _TARW {
-                _TARW { w: self }
-            }
-            #[doc = "Bits 9:12 - TCLR"]
-            #[inline]
-            pub fn tclr(&mut self) -> _TCLRW {
-                _TCLRW { w: self }
-            }
-            #[doc = "Bit 6 - ECCEN"]
-            #[inline]
-            pub fn eccen(&mut self) -> _ECCENW {
-                _ECCENW { w: self }
-            }
-            #[doc = "Bits 4:5 - PWID"]
-            #[inline]
-            pub fn pwid(&mut self) -> _PWIDW {
-                _PWIDW { w: self }
-            }
-            #[doc = "Bit 3 - PTYP"]
-            #[inline]
-            pub fn ptyp(&mut self) -> _PTYPW {
-                _PTYPW { w: self }
-            }
-            #[doc = "Bit 2 - PBKEN"]
-            #[inline]
-            pub fn pbken(&mut self) -> _PBKENW {
-                _PBKENW { w: self }
-            }
-            #[doc = "Bit 1 - PWAITEN"]
-            #[inline]
-            pub fn pwaiten(&mut self) -> _PWAITENW {
-                _PWAITENW { w: self }
-            }
-        }
-    }
-    #[doc = "FIFO status and interrupt register 4"]
-    pub struct SR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "FIFO status and interrupt register 4"]
-    pub mod sr4 {
-        #[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::SR4 {
-            #[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 = r" Value of the field"]
-        pub struct FEMPTR {
-            bits: bool,
-        }
-        impl FEMPTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IFENR {
-            bits: bool,
-        }
-        impl IFENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ILENR {
-            bits: bool,
-        }
-        impl ILENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IRENR {
-            bits: bool,
-        }
-        impl IRENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IFSR {
-            bits: bool,
-        }
-        impl IFSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ILSR {
-            bits: bool,
-        }
-        impl ILSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IRSR {
-            bits: bool,
-        }
-        impl IRSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _IFENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IFENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ILENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ILENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IRENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IRENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IFSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IFSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ILSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ILSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IRSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IRSW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - FEMPT"]
-            #[inline]
-            pub fn fempt(&self) -> FEMPTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FEMPTR { bits }
-            }
-            #[doc = "Bit 5 - IFEN"]
-            #[inline]
-            pub fn ifen(&self) -> IFENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IFENR { bits }
-            }
-            #[doc = "Bit 4 - ILEN"]
-            #[inline]
-            pub fn ilen(&self) -> ILENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ILENR { bits }
-            }
-            #[doc = "Bit 3 - IREN"]
-            #[inline]
-            pub fn iren(&self) -> IRENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IRENR { bits }
-            }
-            #[doc = "Bit 2 - IFS"]
-            #[inline]
-            pub fn ifs(&self) -> IFSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IFSR { bits }
-            }
-            #[doc = "Bit 1 - ILS"]
-            #[inline]
-            pub fn ils(&self) -> ILSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ILSR { bits }
-            }
-            #[doc = "Bit 0 - IRS"]
-            #[inline]
-            pub fn irs(&self) -> IRSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IRSR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x40 }
-            }
-            #[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 5 - IFEN"]
-            #[inline]
-            pub fn ifen(&mut self) -> _IFENW {
-                _IFENW { w: self }
-            }
-            #[doc = "Bit 4 - ILEN"]
-            #[inline]
-            pub fn ilen(&mut self) -> _ILENW {
-                _ILENW { w: self }
-            }
-            #[doc = "Bit 3 - IREN"]
-            #[inline]
-            pub fn iren(&mut self) -> _IRENW {
-                _IRENW { w: self }
-            }
-            #[doc = "Bit 2 - IFS"]
-            #[inline]
-            pub fn ifs(&mut self) -> _IFSW {
-                _IFSW { w: self }
-            }
-            #[doc = "Bit 1 - ILS"]
-            #[inline]
-            pub fn ils(&mut self) -> _ILSW {
-                _ILSW { w: self }
-            }
-            #[doc = "Bit 0 - IRS"]
-            #[inline]
-            pub fn irs(&mut self) -> _IRSW {
-                _IRSW { w: self }
-            }
-        }
-    }
-    #[doc = "Common memory space timing register 4"]
-    pub struct PMEM4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Common memory space timing register 4"]
-    pub mod pmem4 {
-        #[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::PMEM4 {
-            #[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 = r" Value of the field"]
-        pub struct MEMHIZXR {
-            bits: u8,
-        }
-        impl MEMHIZXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMHOLDXR {
-            bits: u8,
-        }
-        impl MEMHOLDXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMWAITXR {
-            bits: u8,
-        }
-        impl MEMWAITXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MEMSETXR {
-            bits: u8,
-        }
-        impl MEMSETXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMHIZXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMHIZXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMHOLDXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMHOLDXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMWAITXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMWAITXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MEMSETXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MEMSETXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - MEMHIZx"]
-            #[inline]
-            pub fn memhizx(&self) -> MEMHIZXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMHIZXR { bits }
-            }
-            #[doc = "Bits 16:23 - MEMHOLDx"]
-            #[inline]
-            pub fn memholdx(&self) -> MEMHOLDXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMHOLDXR { bits }
-            }
-            #[doc = "Bits 8:15 - MEMWAITx"]
-            #[inline]
-            pub fn memwaitx(&self) -> MEMWAITXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMWAITXR { bits }
-            }
-            #[doc = "Bits 0:7 - MEMSETx"]
-            #[inline]
-            pub fn memsetx(&self) -> MEMSETXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MEMSETXR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xfcfc_fcfc }
-            }
-            #[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 24:31 - MEMHIZx"]
-            #[inline]
-            pub fn memhizx(&mut self) -> _MEMHIZXW {
-                _MEMHIZXW { w: self }
-            }
-            #[doc = "Bits 16:23 - MEMHOLDx"]
-            #[inline]
-            pub fn memholdx(&mut self) -> _MEMHOLDXW {
-                _MEMHOLDXW { w: self }
-            }
-            #[doc = "Bits 8:15 - MEMWAITx"]
-            #[inline]
-            pub fn memwaitx(&mut self) -> _MEMWAITXW {
-                _MEMWAITXW { w: self }
-            }
-            #[doc = "Bits 0:7 - MEMSETx"]
-            #[inline]
-            pub fn memsetx(&mut self) -> _MEMSETXW {
-                _MEMSETXW { w: self }
-            }
-        }
-    }
-    #[doc = "Attribute memory space timing register 4"]
-    pub struct PATT4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Attribute memory space timing register 4"]
-    pub mod patt4 {
-        #[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::PATT4 {
-            #[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 = r" Value of the field"]
-        pub struct ATTHIZXR {
-            bits: u8,
-        }
-        impl ATTHIZXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTHOLDXR {
-            bits: u8,
-        }
-        impl ATTHOLDXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTWAITXR {
-            bits: u8,
-        }
-        impl ATTWAITXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ATTSETXR {
-            bits: u8,
-        }
-        impl ATTSETXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTHIZXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTHIZXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTHOLDXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTHOLDXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTWAITXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTWAITXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ATTSETXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ATTSETXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - ATTHIZx"]
-            #[inline]
-            pub fn atthizx(&self) -> ATTHIZXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTHIZXR { bits }
-            }
-            #[doc = "Bits 16:23 - ATTHOLDx"]
-            #[inline]
-            pub fn attholdx(&self) -> ATTHOLDXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTHOLDXR { bits }
-            }
-            #[doc = "Bits 8:15 - ATTWAITx"]
-            #[inline]
-            pub fn attwaitx(&self) -> ATTWAITXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTWAITXR { bits }
-            }
-            #[doc = "Bits 0:7 - ATTSETx"]
-            #[inline]
-            pub fn attsetx(&self) -> ATTSETXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ATTSETXR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xfcfc_fcfc }
-            }
-            #[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 24:31 - ATTHIZx"]
-            #[inline]
-            pub fn atthizx(&mut self) -> _ATTHIZXW {
-                _ATTHIZXW { w: self }
-            }
-            #[doc = "Bits 16:23 - ATTHOLDx"]
-            #[inline]
-            pub fn attholdx(&mut self) -> _ATTHOLDXW {
-                _ATTHOLDXW { w: self }
-            }
-            #[doc = "Bits 8:15 - ATTWAITx"]
-            #[inline]
-            pub fn attwaitx(&mut self) -> _ATTWAITXW {
-                _ATTWAITXW { w: self }
-            }
-            #[doc = "Bits 0:7 - ATTSETx"]
-            #[inline]
-            pub fn attsetx(&mut self) -> _ATTSETXW {
-                _ATTSETXW { w: self }
-            }
-        }
-    }
-    #[doc = "I/O space timing register 4"]
-    pub struct PIO4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "I/O space timing register 4"]
-    pub mod pio4 {
-        #[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::PIO4 {
-            #[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 = r" Value of the field"]
-        pub struct IOHIZXR {
-            bits: u8,
-        }
-        impl IOHIZXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IOHOLDXR {
-            bits: u8,
-        }
-        impl IOHOLDXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IOWAITXR {
-            bits: u8,
-        }
-        impl IOWAITXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IOSETXR {
-            bits: u8,
-        }
-        impl IOSETXR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IOHIZXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IOHIZXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IOHOLDXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IOHOLDXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IOWAITXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IOWAITXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IOSETXW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IOSETXW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 24:31 - IOHIZx"]
-            #[inline]
-            pub fn iohizx(&self) -> IOHIZXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IOHIZXR { bits }
-            }
-            #[doc = "Bits 16:23 - IOHOLDx"]
-            #[inline]
-            pub fn ioholdx(&self) -> IOHOLDXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IOHOLDXR { bits }
-            }
-            #[doc = "Bits 8:15 - IOWAITx"]
-            #[inline]
-            pub fn iowaitx(&self) -> IOWAITXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IOWAITXR { bits }
-            }
-            #[doc = "Bits 0:7 - IOSETx"]
-            #[inline]
-            pub fn iosetx(&self) -> IOSETXR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IOSETXR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xfcfc_fcfc }
-            }
-            #[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 24:31 - IOHIZx"]
-            #[inline]
-            pub fn iohizx(&mut self) -> _IOHIZXW {
-                _IOHIZXW { w: self }
-            }
-            #[doc = "Bits 16:23 - IOHOLDx"]
-            #[inline]
-            pub fn ioholdx(&mut self) -> _IOHOLDXW {
-                _IOHOLDXW { w: self }
-            }
-            #[doc = "Bits 8:15 - IOWAITx"]
-            #[inline]
-            pub fn iowaitx(&mut self) -> _IOWAITXW {
-                _IOWAITXW { w: self }
-            }
-            #[doc = "Bits 0:7 - IOSETx"]
-            #[inline]
-            pub fn iosetx(&mut self) -> _IOSETXW {
-                _IOSETXW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash write timing registers 1"]
-    pub struct BWTR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash write timing registers 1"]
-    pub mod bwtr1 {
-        #[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::BWTR1 {
-            #[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 = r" Value of the field"]
-        pub struct ACCMODR {
-            bits: u8,
-        }
-        impl ACCMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATLATR {
-            bits: u8,
-        }
-        impl DATLATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATASTR {
-            bits: u8,
-        }
-        impl DATASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDHLDR {
-            bits: u8,
-        }
-        impl ADDHLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDSETR {
-            bits: u8,
-        }
-        impl ADDSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACCMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACCMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATLATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLATW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATASTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDHLDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDHLDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&self) -> ACCMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ACCMODR { bits }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&self) -> DATLATR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLATR { bits }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&self) -> DATASTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATASTR { bits }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&self) -> ADDHLDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDHLDR { bits }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&self) -> ADDSETR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDSETR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0fff_ffff }
-            }
-            #[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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&mut self) -> _ACCMODW {
-                _ACCMODW { w: self }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&mut self) -> _DATLATW {
-                _DATLATW { w: self }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&mut self) -> _DATASTW {
-                _DATASTW { w: self }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&mut self) -> _ADDHLDW {
-                _ADDHLDW { w: self }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&mut self) -> _ADDSETW {
-                _ADDSETW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash write timing registers 2"]
-    pub struct BWTR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash write timing registers 2"]
-    pub mod bwtr2 {
-        #[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::BWTR2 {
-            #[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 = r" Value of the field"]
-        pub struct ACCMODR {
-            bits: u8,
-        }
-        impl ACCMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATLATR {
-            bits: u8,
-        }
-        impl DATLATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATASTR {
-            bits: u8,
-        }
-        impl DATASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDHLDR {
-            bits: u8,
-        }
-        impl ADDHLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDSETR {
-            bits: u8,
-        }
-        impl ADDSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACCMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACCMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATLATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLATW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATASTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDHLDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDHLDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&self) -> ACCMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ACCMODR { bits }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&self) -> DATLATR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLATR { bits }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&self) -> DATASTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATASTR { bits }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&self) -> ADDHLDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDHLDR { bits }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&self) -> ADDSETR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDSETR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0fff_ffff }
-            }
-            #[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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&mut self) -> _ACCMODW {
-                _ACCMODW { w: self }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&mut self) -> _DATLATW {
-                _DATLATW { w: self }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&mut self) -> _DATASTW {
-                _DATASTW { w: self }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&mut self) -> _ADDHLDW {
-                _ADDHLDW { w: self }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&mut self) -> _ADDSETW {
-                _ADDSETW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash write timing registers 3"]
-    pub struct BWTR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash write timing registers 3"]
-    pub mod bwtr3 {
-        #[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::BWTR3 {
-            #[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 = r" Value of the field"]
-        pub struct ACCMODR {
-            bits: u8,
-        }
-        impl ACCMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATLATR {
-            bits: u8,
-        }
-        impl DATLATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATASTR {
-            bits: u8,
-        }
-        impl DATASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDHLDR {
-            bits: u8,
-        }
-        impl ADDHLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDSETR {
-            bits: u8,
-        }
-        impl ADDSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACCMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACCMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATLATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLATW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATASTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDHLDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDHLDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&self) -> ACCMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ACCMODR { bits }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&self) -> DATLATR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLATR { bits }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&self) -> DATASTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATASTR { bits }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&self) -> ADDHLDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDHLDR { bits }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&self) -> ADDSETR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDSETR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0fff_ffff }
-            }
-            #[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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&mut self) -> _ACCMODW {
-                _ACCMODW { w: self }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&mut self) -> _DATLATW {
-                _DATLATW { w: self }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&mut self) -> _DATASTW {
-                _DATASTW { w: self }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&mut self) -> _ADDHLDW {
-                _ADDHLDW { w: self }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&mut self) -> _ADDSETW {
-                _ADDSETW { w: self }
-            }
-        }
-    }
-    #[doc = "SRAM/NOR-Flash write timing registers 4"]
-    pub struct BWTR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "SRAM/NOR-Flash write timing registers 4"]
-    pub mod bwtr4 {
-        #[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::BWTR4 {
-            #[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 = r" Value of the field"]
-        pub struct ACCMODR {
-            bits: u8,
-        }
-        impl ACCMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATLATR {
-            bits: u8,
-        }
-        impl DATLATR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CLKDIVR {
-            bits: u8,
-        }
-        impl CLKDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATASTR {
-            bits: u8,
-        }
-        impl DATASTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDHLDR {
-            bits: u8,
-        }
-        impl ADDHLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADDSETR {
-            bits: u8,
-        }
-        impl ADDSETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ACCMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACCMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 28;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATLATW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATLATW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CLKDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CLKDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATASTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATASTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDHLDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDHLDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDSETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDSETW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&self) -> ACCMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ACCMODR { bits }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&self) -> DATLATR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATLATR { bits }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&self) -> CLKDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CLKDIVR { bits }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&self) -> DATASTR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATASTR { bits }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&self) -> ADDHLDR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDHLDR { bits }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&self) -> ADDSETR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADDSETR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0fff_ffff }
-            }
-            #[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 28:29 - ACCMOD"]
-            #[inline]
-            pub fn accmod(&mut self) -> _ACCMODW {
-                _ACCMODW { w: self }
-            }
-            #[doc = "Bits 24:27 - DATLAT"]
-            #[inline]
-            pub fn datlat(&mut self) -> _DATLATW {
-                _DATLATW { w: self }
-            }
-            #[doc = "Bits 20:23 - CLKDIV"]
-            #[inline]
-            pub fn clkdiv(&mut self) -> _CLKDIVW {
-                _CLKDIVW { w: self }
-            }
-            #[doc = "Bits 8:15 - DATAST"]
-            #[inline]
-            pub fn datast(&mut self) -> _DATASTW {
-                _DATASTW { w: self }
-            }
-            #[doc = "Bits 4:7 - ADDHLD"]
-            #[inline]
-            pub fn addhld(&mut self) -> _ADDHLDW {
-                _ADDHLDW { w: self }
-            }
-            #[doc = "Bits 0:3 - ADDSET"]
-            #[inline]
-            pub fn addset(&mut self) -> _ADDSETW {
-                _ADDSETW { w: self }
-            }
-        }
-    }
-}
-#[doc = "USB on the go full speed"]
-pub struct OTG_FS_GLOBAL {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for OTG_FS_GLOBAL {}
-impl OTG_FS_GLOBAL {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const otg_fs_global::RegisterBlock {
-        0x5000_0000 as *const _
-    }
-}
-impl Deref for OTG_FS_GLOBAL {
-    type Target = otg_fs_global::RegisterBlock;
-    fn deref(&self) -> &otg_fs_global::RegisterBlock {
-        unsafe { &*OTG_FS_GLOBAL::ptr() }
-    }
-}
-#[doc = "USB on the go full speed"]
-pub mod otg_fs_global {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - OTG_FS control and status register (OTG_FS_GOTGCTL)"]
-        pub fs_gotgctl: FS_GOTGCTL,
-        #[doc = "0x04 - OTG_FS interrupt register (OTG_FS_GOTGINT)"]
-        pub fs_gotgint: FS_GOTGINT,
-        #[doc = "0x08 - OTG_FS AHB configuration register (OTG_FS_GAHBCFG)"]
-        pub fs_gahbcfg: FS_GAHBCFG,
-        #[doc = "0x0c - OTG_FS USB configuration register (OTG_FS_GUSBCFG)"]
-        pub fs_gusbcfg: FS_GUSBCFG,
-        #[doc = "0x10 - OTG_FS reset register (OTG_FS_GRSTCTL)"]
-        pub fs_grstctl: FS_GRSTCTL,
-        #[doc = "0x14 - OTG_FS core interrupt register (OTG_FS_GINTSTS)"]
-        pub fs_gintsts: FS_GINTSTS,
-        #[doc = "0x18 - OTG_FS interrupt mask register (OTG_FS_GINTMSK)"]
-        pub fs_gintmsk: FS_GINTMSK,
-        #[doc = "0x1c - OTG_FS Receive status debug read(Device mode)"]
-        pub fs_grxstsr_device: FS_GRXSTSR_DEVICE,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x24 - OTG_FS Receive FIFO size register (OTG_FS_GRXFSIZ)"]
-        pub fs_grxfsiz: FS_GRXFSIZ,
-        #[doc = "0x28 - OTG_FS non-periodic transmit FIFO size register (Device mode)"]
-        pub fs_gnptxfsiz_device: FS_GNPTXFSIZ_DEVICE,
-        #[doc = "0x2c - OTG_FS non-periodic transmit FIFO/queue status register (OTG_FS_GNPTXSTS)"]
-        pub fs_gnptxsts: FS_GNPTXSTS,
-        _reserved1: [u8; 8usize],
-        #[doc = "0x38 - OTG_FS general core configuration register (OTG_FS_GCCFG)"]
-        pub fs_gccfg: FS_GCCFG,
-        #[doc = "0x3c - core ID register"]
-        pub fs_cid: FS_CID,
-        _reserved2: [u8; 192usize],
-        #[doc = "0x100 - OTG_FS Host periodic transmit FIFO size register (OTG_FS_HPTXFSIZ)"]
-        pub fs_hptxfsiz: FS_HPTXFSIZ,
-        #[doc = "0x104 - OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF2)"]
-        pub fs_dieptxf1: FS_DIEPTXF1,
-        #[doc = "0x108 - OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF3)"]
-        pub fs_dieptxf2: FS_DIEPTXF2,
-        #[doc = "0x10c - OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF4)"]
-        pub fs_dieptxf3: FS_DIEPTXF3,
-    }
-    #[doc = "OTG_FS control and status register (OTG_FS_GOTGCTL)"]
-    pub struct FS_GOTGCTL {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS control and status register (OTG_FS_GOTGCTL)"]
-    pub mod fs_gotgctl {
-        #[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::FS_GOTGCTL {
-            #[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 = r" Value of the field"]
-        pub struct SRQSCSR {
-            bits: bool,
-        }
-        impl SRQSCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SRQR {
-            bits: bool,
-        }
-        impl SRQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HNGSCSR {
-            bits: bool,
-        }
-        impl HNGSCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HNPRQR {
-            bits: bool,
-        }
-        impl HNPRQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSHNPENR {
-            bits: bool,
-        }
-        impl HSHNPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DHNPENR {
-            bits: bool,
-        }
-        impl DHNPENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIDSTSR {
-            bits: bool,
-        }
-        impl CIDSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBCTR {
-            bits: bool,
-        }
-        impl DBCTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ASVLDR {
-            bits: bool,
-        }
-        impl ASVLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BSVLDR {
-            bits: bool,
-        }
-        impl BSVLDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SRQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SRQW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HNPRQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HNPRQW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSHNPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSHNPENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DHNPENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DHNPENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Session request success"]
-            #[inline]
-            pub fn srqscs(&self) -> SRQSCSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRQSCSR { bits }
-            }
-            #[doc = "Bit 1 - Session request"]
-            #[inline]
-            pub fn srq(&self) -> SRQR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRQR { bits }
-            }
-            #[doc = "Bit 8 - Host negotiation success"]
-            #[inline]
-            pub fn hngscs(&self) -> HNGSCSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HNGSCSR { bits }
-            }
-            #[doc = "Bit 9 - HNP request"]
-            #[inline]
-            pub fn hnprq(&self) -> HNPRQR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HNPRQR { bits }
-            }
-            #[doc = "Bit 10 - Host set HNP enable"]
-            #[inline]
-            pub fn hshnpen(&self) -> HSHNPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSHNPENR { bits }
-            }
-            #[doc = "Bit 11 - Device HNP enabled"]
-            #[inline]
-            pub fn dhnpen(&self) -> DHNPENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DHNPENR { bits }
-            }
-            #[doc = "Bit 16 - Connector ID status"]
-            #[inline]
-            pub fn cidsts(&self) -> CIDSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIDSTSR { bits }
-            }
-            #[doc = "Bit 17 - Long/short debounce time"]
-            #[inline]
-            pub fn dbct(&self) -> DBCTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBCTR { bits }
-            }
-            #[doc = "Bit 18 - A-session valid"]
-            #[inline]
-            pub fn asvld(&self) -> ASVLDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ASVLDR { bits }
-            }
-            #[doc = "Bit 19 - B-session valid"]
-            #[inline]
-            pub fn bsvld(&self) -> BSVLDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BSVLDR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0800 }
-            }
-            #[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 1 - Session request"]
-            #[inline]
-            pub fn srq(&mut self) -> _SRQW {
-                _SRQW { w: self }
-            }
-            #[doc = "Bit 9 - HNP request"]
-            #[inline]
-            pub fn hnprq(&mut self) -> _HNPRQW {
-                _HNPRQW { w: self }
-            }
-            #[doc = "Bit 10 - Host set HNP enable"]
-            #[inline]
-            pub fn hshnpen(&mut self) -> _HSHNPENW {
-                _HSHNPENW { w: self }
-            }
-            #[doc = "Bit 11 - Device HNP enabled"]
-            #[inline]
-            pub fn dhnpen(&mut self) -> _DHNPENW {
-                _DHNPENW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS interrupt register (OTG_FS_GOTGINT)"]
-    pub struct FS_GOTGINT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS interrupt register (OTG_FS_GOTGINT)"]
-    pub mod fs_gotgint {
-        #[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::FS_GOTGINT {
-            #[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 = r" Value of the field"]
-        pub struct SEDETR {
-            bits: bool,
-        }
-        impl SEDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SRSSCHGR {
-            bits: bool,
-        }
-        impl SRSSCHGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HNSSCHGR {
-            bits: bool,
-        }
-        impl HNSSCHGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HNGDETR {
-            bits: bool,
-        }
-        impl HNGDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ADTOCHGR {
-            bits: bool,
-        }
-        impl ADTOCHGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DBCDNER {
-            bits: bool,
-        }
-        impl DBCDNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _SEDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SEDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SRSSCHGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SRSSCHGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HNSSCHGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HNSSCHGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HNGDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HNGDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ADTOCHGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADTOCHGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DBCDNEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DBCDNEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 2 - Session end detected"]
-            #[inline]
-            pub fn sedet(&self) -> SEDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SEDETR { bits }
-            }
-            #[doc = "Bit 8 - Session request success status change"]
-            #[inline]
-            pub fn srsschg(&self) -> SRSSCHGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRSSCHGR { bits }
-            }
-            #[doc = "Bit 9 - Host negotiation success status change"]
-            #[inline]
-            pub fn hnsschg(&self) -> HNSSCHGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HNSSCHGR { bits }
-            }
-            #[doc = "Bit 17 - Host negotiation detected"]
-            #[inline]
-            pub fn hngdet(&self) -> HNGDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HNGDETR { bits }
-            }
-            #[doc = "Bit 18 - A-device timeout change"]
-            #[inline]
-            pub fn adtochg(&self) -> ADTOCHGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ADTOCHGR { bits }
-            }
-            #[doc = "Bit 19 - Debounce done"]
-            #[inline]
-            pub fn dbcdne(&self) -> DBCDNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DBCDNER { bits }
-            }
-        }
-        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 2 - Session end detected"]
-            #[inline]
-            pub fn sedet(&mut self) -> _SEDETW {
-                _SEDETW { w: self }
-            }
-            #[doc = "Bit 8 - Session request success status change"]
-            #[inline]
-            pub fn srsschg(&mut self) -> _SRSSCHGW {
-                _SRSSCHGW { w: self }
-            }
-            #[doc = "Bit 9 - Host negotiation success status change"]
-            #[inline]
-            pub fn hnsschg(&mut self) -> _HNSSCHGW {
-                _HNSSCHGW { w: self }
-            }
-            #[doc = "Bit 17 - Host negotiation detected"]
-            #[inline]
-            pub fn hngdet(&mut self) -> _HNGDETW {
-                _HNGDETW { w: self }
-            }
-            #[doc = "Bit 18 - A-device timeout change"]
-            #[inline]
-            pub fn adtochg(&mut self) -> _ADTOCHGW {
-                _ADTOCHGW { w: self }
-            }
-            #[doc = "Bit 19 - Debounce done"]
-            #[inline]
-            pub fn dbcdne(&mut self) -> _DBCDNEW {
-                _DBCDNEW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS AHB configuration register (OTG_FS_GAHBCFG)"]
-    pub struct FS_GAHBCFG {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS AHB configuration register (OTG_FS_GAHBCFG)"]
-    pub mod fs_gahbcfg {
-        #[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::FS_GAHBCFG {
-            #[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 = r" Value of the field"]
-        pub struct GINTR {
-            bits: bool,
-        }
-        impl GINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFELVLR {
-            bits: bool,
-        }
-        impl TXFELVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PTXFELVLR {
-            bits: bool,
-        }
-        impl PTXFELVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _GINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GINTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFELVLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFELVLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PTXFELVLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTXFELVLW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Global interrupt mask"]
-            #[inline]
-            pub fn gint(&self) -> GINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GINTR { bits }
-            }
-            #[doc = "Bit 7 - TxFIFO empty level"]
-            #[inline]
-            pub fn txfelvl(&self) -> TXFELVLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFELVLR { bits }
-            }
-            #[doc = "Bit 8 - Periodic TxFIFO empty level"]
-            #[inline]
-            pub fn ptxfelvl(&self) -> PTXFELVLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PTXFELVLR { bits }
-            }
-        }
-        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 - Global interrupt mask"]
-            #[inline]
-            pub fn gint(&mut self) -> _GINTW {
-                _GINTW { w: self }
-            }
-            #[doc = "Bit 7 - TxFIFO empty level"]
-            #[inline]
-            pub fn txfelvl(&mut self) -> _TXFELVLW {
-                _TXFELVLW { w: self }
-            }
-            #[doc = "Bit 8 - Periodic TxFIFO empty level"]
-            #[inline]
-            pub fn ptxfelvl(&mut self) -> _PTXFELVLW {
-                _PTXFELVLW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS USB configuration register (OTG_FS_GUSBCFG)"]
-    pub struct FS_GUSBCFG {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS USB configuration register (OTG_FS_GUSBCFG)"]
-    pub mod fs_gusbcfg {
-        #[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::FS_GUSBCFG {
-            #[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 = r" Value of the field"]
-        pub struct TOCALR {
-            bits: u8,
-        }
-        impl TOCALR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SRPCAPR {
-            bits: bool,
-        }
-        impl SRPCAPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HNPCAPR {
-            bits: bool,
-        }
-        impl HNPCAPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TRDTR {
-            bits: u8,
-        }
-        impl TRDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FHMODR {
-            bits: bool,
-        }
-        impl FHMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FDMODR {
-            bits: bool,
-        }
-        impl FDMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTXPKTR {
-            bits: bool,
-        }
-        impl CTXPKTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _TOCALW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TOCALW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PHYSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PHYSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SRPCAPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SRPCAPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HNPCAPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HNPCAPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TRDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FHMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FHMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FDMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FDMODW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTXPKTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTXPKTW<'a> {
-            #[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 = "Bits 0:2 - FS timeout calibration"]
-            #[inline]
-            pub fn tocal(&self) -> TOCALR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TOCALR { bits }
-            }
-            #[doc = "Bit 8 - SRP-capable"]
-            #[inline]
-            pub fn srpcap(&self) -> SRPCAPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRPCAPR { bits }
-            }
-            #[doc = "Bit 9 - HNP-capable"]
-            #[inline]
-            pub fn hnpcap(&self) -> HNPCAPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HNPCAPR { bits }
-            }
-            #[doc = "Bits 10:13 - USB turnaround time"]
-            #[inline]
-            pub fn trdt(&self) -> TRDTR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TRDTR { bits }
-            }
-            #[doc = "Bit 29 - Force host mode"]
-            #[inline]
-            pub fn fhmod(&self) -> FHMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FHMODR { bits }
-            }
-            #[doc = "Bit 30 - Force device mode"]
-            #[inline]
-            pub fn fdmod(&self) -> FDMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FDMODR { bits }
-            }
-            #[doc = "Bit 31 - Corrupt Tx packet"]
-            #[inline]
-            pub fn ctxpkt(&self) -> CTXPKTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTXPKTR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0a00 }
-            }
-            #[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 0:2 - FS timeout calibration"]
-            #[inline]
-            pub fn tocal(&mut self) -> _TOCALW {
-                _TOCALW { w: self }
-            }
-            #[doc = "Bit 6 - Full Speed serial transceiver select"]
-            #[inline]
-            pub fn physel(&mut self) -> _PHYSELW {
-                _PHYSELW { w: self }
-            }
-            #[doc = "Bit 8 - SRP-capable"]
-            #[inline]
-            pub fn srpcap(&mut self) -> _SRPCAPW {
-                _SRPCAPW { w: self }
-            }
-            #[doc = "Bit 9 - HNP-capable"]
-            #[inline]
-            pub fn hnpcap(&mut self) -> _HNPCAPW {
-                _HNPCAPW { w: self }
-            }
-            #[doc = "Bits 10:13 - USB turnaround time"]
-            #[inline]
-            pub fn trdt(&mut self) -> _TRDTW {
-                _TRDTW { w: self }
-            }
-            #[doc = "Bit 29 - Force host mode"]
-            #[inline]
-            pub fn fhmod(&mut self) -> _FHMODW {
-                _FHMODW { w: self }
-            }
-            #[doc = "Bit 30 - Force device mode"]
-            #[inline]
-            pub fn fdmod(&mut self) -> _FDMODW {
-                _FDMODW { w: self }
-            }
-            #[doc = "Bit 31 - Corrupt Tx packet"]
-            #[inline]
-            pub fn ctxpkt(&mut self) -> _CTXPKTW {
-                _CTXPKTW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS reset register (OTG_FS_GRSTCTL)"]
-    pub struct FS_GRSTCTL {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS reset register (OTG_FS_GRSTCTL)"]
-    pub mod fs_grstctl {
-        #[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::FS_GRSTCTL {
-            #[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 = r" Value of the field"]
-        pub struct CSRSTR {
-            bits: bool,
-        }
-        impl CSRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HSRSTR {
-            bits: bool,
-        }
-        impl HSRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FCRSTR {
-            bits: bool,
-        }
-        impl FCRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFFLSHR {
-            bits: bool,
-        }
-        impl RXFFLSHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFFLSHR {
-            bits: bool,
-        }
-        impl TXFFLSHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFNUMR {
-            bits: u8,
-        }
-        impl TXFNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AHBIDLR {
-            bits: bool,
-        }
-        impl AHBIDLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CSRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CSRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HSRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HSRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FCRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FCRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXFFLSHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXFFLSHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFFLSHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFFLSHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 6;
-                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 - Core soft reset"]
-            #[inline]
-            pub fn csrst(&self) -> CSRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CSRSTR { bits }
-            }
-            #[doc = "Bit 1 - HCLK soft reset"]
-            #[inline]
-            pub fn hsrst(&self) -> HSRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HSRSTR { bits }
-            }
-            #[doc = "Bit 2 - Host frame counter reset"]
-            #[inline]
-            pub fn fcrst(&self) -> FCRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FCRSTR { bits }
-            }
-            #[doc = "Bit 4 - RxFIFO flush"]
-            #[inline]
-            pub fn rxfflsh(&self) -> RXFFLSHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFFLSHR { bits }
-            }
-            #[doc = "Bit 5 - TxFIFO flush"]
-            #[inline]
-            pub fn txfflsh(&self) -> TXFFLSHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFFLSHR { bits }
-            }
-            #[doc = "Bits 6:10 - TxFIFO number"]
-            #[inline]
-            pub fn txfnum(&self) -> TXFNUMR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TXFNUMR { bits }
-            }
-            #[doc = "Bit 31 - AHB master idle"]
-            #[inline]
-            pub fn ahbidl(&self) -> AHBIDLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AHBIDLR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x2000_0000 }
-            }
-            #[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 - Core soft reset"]
-            #[inline]
-            pub fn csrst(&mut self) -> _CSRSTW {
-                _CSRSTW { w: self }
-            }
-            #[doc = "Bit 1 - HCLK soft reset"]
-            #[inline]
-            pub fn hsrst(&mut self) -> _HSRSTW {
-                _HSRSTW { w: self }
-            }
-            #[doc = "Bit 2 - Host frame counter reset"]
-            #[inline]
-            pub fn fcrst(&mut self) -> _FCRSTW {
-                _FCRSTW { w: self }
-            }
-            #[doc = "Bit 4 - RxFIFO flush"]
-            #[inline]
-            pub fn rxfflsh(&mut self) -> _RXFFLSHW {
-                _RXFFLSHW { w: self }
-            }
-            #[doc = "Bit 5 - TxFIFO flush"]
-            #[inline]
-            pub fn txfflsh(&mut self) -> _TXFFLSHW {
-                _TXFFLSHW { w: self }
-            }
-            #[doc = "Bits 6:10 - TxFIFO number"]
-            #[inline]
-            pub fn txfnum(&mut self) -> _TXFNUMW {
-                _TXFNUMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS core interrupt register (OTG_FS_GINTSTS)"]
-    pub struct FS_GINTSTS {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS core interrupt register (OTG_FS_GINTSTS)"]
-    pub mod fs_gintsts {
-        #[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::FS_GINTSTS {
-            #[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 = r" Value of the field"]
-        pub struct CMODR {
-            bits: bool,
-        }
-        impl CMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MMISR {
-            bits: bool,
-        }
-        impl MMISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OTGINTR {
-            bits: bool,
-        }
-        impl OTGINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SOFR {
-            bits: bool,
-        }
-        impl SOFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFLVLR {
-            bits: bool,
-        }
-        impl RXFLVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NPTXFER {
-            bits: bool,
-        }
-        impl NPTXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GINAKEFFR {
-            bits: bool,
-        }
-        impl GINAKEFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GOUTNAKEFFR {
-            bits: bool,
-        }
-        impl GOUTNAKEFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ESUSPR {
-            bits: bool,
-        }
-        impl ESUSPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBSUSPR {
-            bits: bool,
-        }
-        impl USBSUSPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBRSTR {
-            bits: bool,
-        }
-        impl USBRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENUMDNER {
-            bits: bool,
-        }
-        impl ENUMDNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ISOODRPR {
-            bits: bool,
-        }
-        impl ISOODRPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EOPFR {
-            bits: bool,
-        }
-        impl EOPFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IEPINTR {
-            bits: bool,
-        }
-        impl IEPINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OEPINTR {
-            bits: bool,
-        }
-        impl OEPINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IISOIXFRR {
-            bits: bool,
-        }
-        impl IISOIXFRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IPXFR_INCOMPISOOUTR {
-            bits: bool,
-        }
-        impl IPXFR_INCOMPISOOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HPRTINTR {
-            bits: bool,
-        }
-        impl HPRTINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HCINTR {
-            bits: bool,
-        }
-        impl HCINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PTXFER {
-            bits: bool,
-        }
-        impl PTXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIDSCHGR {
-            bits: bool,
-        }
-        impl CIDSCHGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DISCINTR {
-            bits: bool,
-        }
-        impl DISCINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SRQINTR {
-            bits: bool,
-        }
-        impl SRQINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WKUPINTR {
-            bits: bool,
-        }
-        impl WKUPINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MMISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MMISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SOFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SOFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ESUSPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ESUSPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USBSUSPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBSUSPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USBRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENUMDNEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENUMDNEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ISOODRPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ISOODRPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EOPFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EOPFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IISOIXFRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IISOIXFRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IPXFR_INCOMPISOOUTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IPXFR_INCOMPISOOUTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIDSCHGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIDSCHGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DISCINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DISCINTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SRQINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SRQINTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WKUPINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WKUPINTW<'a> {
-            #[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 - Current mode of operation"]
-            #[inline]
-            pub fn cmod(&self) -> CMODR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMODR { bits }
-            }
-            #[doc = "Bit 1 - Mode mismatch interrupt"]
-            #[inline]
-            pub fn mmis(&self) -> MMISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MMISR { bits }
-            }
-            #[doc = "Bit 2 - OTG interrupt"]
-            #[inline]
-            pub fn otgint(&self) -> OTGINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTGINTR { bits }
-            }
-            #[doc = "Bit 3 - Start of frame"]
-            #[inline]
-            pub fn sof(&self) -> SOFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SOFR { bits }
-            }
-            #[doc = "Bit 4 - RxFIFO non-empty"]
-            #[inline]
-            pub fn rxflvl(&self) -> RXFLVLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFLVLR { bits }
-            }
-            #[doc = "Bit 5 - Non-periodic TxFIFO empty"]
-            #[inline]
-            pub fn nptxfe(&self) -> NPTXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NPTXFER { bits }
-            }
-            #[doc = "Bit 6 - Global IN non-periodic NAK effective"]
-            #[inline]
-            pub fn ginakeff(&self) -> GINAKEFFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GINAKEFFR { bits }
-            }
-            #[doc = "Bit 7 - Global OUT NAK effective"]
-            #[inline]
-            pub fn goutnakeff(&self) -> GOUTNAKEFFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GOUTNAKEFFR { bits }
-            }
-            #[doc = "Bit 10 - Early suspend"]
-            #[inline]
-            pub fn esusp(&self) -> ESUSPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ESUSPR { bits }
-            }
-            #[doc = "Bit 11 - USB suspend"]
-            #[inline]
-            pub fn usbsusp(&self) -> USBSUSPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBSUSPR { bits }
-            }
-            #[doc = "Bit 12 - USB reset"]
-            #[inline]
-            pub fn usbrst(&self) -> USBRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBRSTR { bits }
-            }
-            #[doc = "Bit 13 - Enumeration done"]
-            #[inline]
-            pub fn enumdne(&self) -> ENUMDNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENUMDNER { bits }
-            }
-            #[doc = "Bit 14 - Isochronous OUT packet dropped interrupt"]
-            #[inline]
-            pub fn isoodrp(&self) -> ISOODRPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ISOODRPR { bits }
-            }
-            #[doc = "Bit 15 - End of periodic frame interrupt"]
-            #[inline]
-            pub fn eopf(&self) -> EOPFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EOPFR { bits }
-            }
-            #[doc = "Bit 18 - IN endpoint interrupt"]
-            #[inline]
-            pub fn iepint(&self) -> IEPINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IEPINTR { bits }
-            }
-            #[doc = "Bit 19 - OUT endpoint interrupt"]
-            #[inline]
-            pub fn oepint(&self) -> OEPINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OEPINTR { bits }
-            }
-            #[doc = "Bit 20 - Incomplete isochronous IN transfer"]
-            #[inline]
-            pub fn iisoixfr(&self) -> IISOIXFRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IISOIXFRR { bits }
-            }
-            # [ doc = "Bit 21 - Incomplete periodic transfer(Host mode)/Incomplete isochronous OUT transfer(Device mode)" ] # [ inline ]
-            pub fn ipxfr_incompisoout(&self) -> IPXFR_INCOMPISOOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IPXFR_INCOMPISOOUTR { bits }
-            }
-            #[doc = "Bit 24 - Host port interrupt"]
-            #[inline]
-            pub fn hprtint(&self) -> HPRTINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HPRTINTR { bits }
-            }
-            #[doc = "Bit 25 - Host channels interrupt"]
-            #[inline]
-            pub fn hcint(&self) -> HCINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HCINTR { bits }
-            }
-            #[doc = "Bit 26 - Periodic TxFIFO empty"]
-            #[inline]
-            pub fn ptxfe(&self) -> PTXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PTXFER { bits }
-            }
-            #[doc = "Bit 28 - Connector ID status change"]
-            #[inline]
-            pub fn cidschg(&self) -> CIDSCHGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIDSCHGR { bits }
-            }
-            #[doc = "Bit 29 - Disconnect detected interrupt"]
-            #[inline]
-            pub fn discint(&self) -> DISCINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DISCINTR { bits }
-            }
-            #[doc = "Bit 30 - Session request/new session detected interrupt"]
-            #[inline]
-            pub fn srqint(&self) -> SRQINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRQINTR { bits }
-            }
-            #[doc = "Bit 31 - Resume/remote wakeup detected interrupt"]
-            #[inline]
-            pub fn wkupint(&self) -> WKUPINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WKUPINTR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0400_0020 }
-            }
-            #[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 1 - Mode mismatch interrupt"]
-            #[inline]
-            pub fn mmis(&mut self) -> _MMISW {
-                _MMISW { w: self }
-            }
-            #[doc = "Bit 3 - Start of frame"]
-            #[inline]
-            pub fn sof(&mut self) -> _SOFW {
-                _SOFW { w: self }
-            }
-            #[doc = "Bit 10 - Early suspend"]
-            #[inline]
-            pub fn esusp(&mut self) -> _ESUSPW {
-                _ESUSPW { w: self }
-            }
-            #[doc = "Bit 11 - USB suspend"]
-            #[inline]
-            pub fn usbsusp(&mut self) -> _USBSUSPW {
-                _USBSUSPW { w: self }
-            }
-            #[doc = "Bit 12 - USB reset"]
-            #[inline]
-            pub fn usbrst(&mut self) -> _USBRSTW {
-                _USBRSTW { w: self }
-            }
-            #[doc = "Bit 13 - Enumeration done"]
-            #[inline]
-            pub fn enumdne(&mut self) -> _ENUMDNEW {
-                _ENUMDNEW { w: self }
-            }
-            #[doc = "Bit 14 - Isochronous OUT packet dropped interrupt"]
-            #[inline]
-            pub fn isoodrp(&mut self) -> _ISOODRPW {
-                _ISOODRPW { w: self }
-            }
-            #[doc = "Bit 15 - End of periodic frame interrupt"]
-            #[inline]
-            pub fn eopf(&mut self) -> _EOPFW {
-                _EOPFW { w: self }
-            }
-            #[doc = "Bit 20 - Incomplete isochronous IN transfer"]
-            #[inline]
-            pub fn iisoixfr(&mut self) -> _IISOIXFRW {
-                _IISOIXFRW { w: self }
-            }
-            # [ doc = "Bit 21 - Incomplete periodic transfer(Host mode)/Incomplete isochronous OUT transfer(Device mode)" ] # [ inline ]
-            pub fn ipxfr_incompisoout(&mut self) -> _IPXFR_INCOMPISOOUTW {
-                _IPXFR_INCOMPISOOUTW { w: self }
-            }
-            #[doc = "Bit 28 - Connector ID status change"]
-            #[inline]
-            pub fn cidschg(&mut self) -> _CIDSCHGW {
-                _CIDSCHGW { w: self }
-            }
-            #[doc = "Bit 29 - Disconnect detected interrupt"]
-            #[inline]
-            pub fn discint(&mut self) -> _DISCINTW {
-                _DISCINTW { w: self }
-            }
-            #[doc = "Bit 30 - Session request/new session detected interrupt"]
-            #[inline]
-            pub fn srqint(&mut self) -> _SRQINTW {
-                _SRQINTW { w: self }
-            }
-            #[doc = "Bit 31 - Resume/remote wakeup detected interrupt"]
-            #[inline]
-            pub fn wkupint(&mut self) -> _WKUPINTW {
-                _WKUPINTW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS interrupt mask register (OTG_FS_GINTMSK)"]
-    pub struct FS_GINTMSK {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS interrupt mask register (OTG_FS_GINTMSK)"]
-    pub mod fs_gintmsk {
-        #[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::FS_GINTMSK {
-            #[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 = r" Value of the field"]
-        pub struct MMISMR {
-            bits: bool,
-        }
-        impl MMISMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OTGINTR {
-            bits: bool,
-        }
-        impl OTGINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SOFMR {
-            bits: bool,
-        }
-        impl SOFMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RXFLVLMR {
-            bits: bool,
-        }
-        impl RXFLVLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NPTXFEMR {
-            bits: bool,
-        }
-        impl NPTXFEMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GINAKEFFMR {
-            bits: bool,
-        }
-        impl GINAKEFFMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GONAKEFFMR {
-            bits: bool,
-        }
-        impl GONAKEFFMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ESUSPMR {
-            bits: bool,
-        }
-        impl ESUSPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBSUSPMR {
-            bits: bool,
-        }
-        impl USBSUSPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBRSTR {
-            bits: bool,
-        }
-        impl USBRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENUMDNEMR {
-            bits: bool,
-        }
-        impl ENUMDNEMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ISOODRPMR {
-            bits: bool,
-        }
-        impl ISOODRPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EOPFMR {
-            bits: bool,
-        }
-        impl EOPFMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPMISMR {
-            bits: bool,
-        }
-        impl EPMISMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IEPINTR {
-            bits: bool,
-        }
-        impl IEPINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OEPINTR {
-            bits: bool,
-        }
-        impl OEPINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IISOIXFRMR {
-            bits: bool,
-        }
-        impl IISOIXFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct IPXFRM_IISOOXFRMR {
-            bits: bool,
-        }
-        impl IPXFRM_IISOOXFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PRTIMR {
-            bits: bool,
-        }
-        impl PRTIMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct HCIMR {
-            bits: bool,
-        }
-        impl HCIMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PTXFEMR {
-            bits: bool,
-        }
-        impl PTXFEMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CIDSCHGMR {
-            bits: bool,
-        }
-        impl CIDSCHGMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DISCINTR {
-            bits: bool,
-        }
-        impl DISCINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SRQIMR {
-            bits: bool,
-        }
-        impl SRQIMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WUIMR {
-            bits: bool,
-        }
-        impl WUIMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MMISMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MMISMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OTGINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTGINTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SOFMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SOFMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _RXFLVLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXFLVLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NPTXFEMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NPTXFEMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GINAKEFFMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GINAKEFFMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GONAKEFFMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GONAKEFFMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ESUSPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ESUSPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USBSUSPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBSUSPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _USBRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENUMDNEMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENUMDNEMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ISOODRPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ISOODRPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EOPFMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EOPFMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPMISMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPMISMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IEPINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IEPINTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OEPINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OEPINTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IISOIXFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IISOIXFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _IPXFRM_IISOOXFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IPXFRM_IISOOXFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _HCIMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HCIMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PTXFEMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTXFEMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CIDSCHGMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CIDSCHGMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DISCINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DISCINTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SRQIMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SRQIMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WUIMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WUIMW<'a> {
-            #[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 1 - Mode mismatch interrupt mask"]
-            #[inline]
-            pub fn mmism(&self) -> MMISMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MMISMR { bits }
-            }
-            #[doc = "Bit 2 - OTG interrupt mask"]
-            #[inline]
-            pub fn otgint(&self) -> OTGINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTGINTR { bits }
-            }
-            #[doc = "Bit 3 - Start of frame mask"]
-            #[inline]
-            pub fn sofm(&self) -> SOFMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SOFMR { bits }
-            }
-            #[doc = "Bit 4 - Receive FIFO non-empty mask"]
-            #[inline]
-            pub fn rxflvlm(&self) -> RXFLVLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RXFLVLMR { bits }
-            }
-            #[doc = "Bit 5 - Non-periodic TxFIFO empty mask"]
-            #[inline]
-            pub fn nptxfem(&self) -> NPTXFEMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NPTXFEMR { bits }
-            }
-            #[doc = "Bit 6 - Global non-periodic IN NAK effective mask"]
-            #[inline]
-            pub fn ginakeffm(&self) -> GINAKEFFMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GINAKEFFMR { bits }
-            }
-            #[doc = "Bit 7 - Global OUT NAK effective mask"]
-            #[inline]
-            pub fn gonakeffm(&self) -> GONAKEFFMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GONAKEFFMR { bits }
-            }
-            #[doc = "Bit 10 - Early suspend mask"]
-            #[inline]
-            pub fn esuspm(&self) -> ESUSPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ESUSPMR { bits }
-            }
-            #[doc = "Bit 11 - USB suspend mask"]
-            #[inline]
-            pub fn usbsuspm(&self) -> USBSUSPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBSUSPMR { bits }
-            }
-            #[doc = "Bit 12 - USB reset mask"]
-            #[inline]
-            pub fn usbrst(&self) -> USBRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBRSTR { bits }
-            }
-            #[doc = "Bit 13 - Enumeration done mask"]
-            #[inline]
-            pub fn enumdnem(&self) -> ENUMDNEMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENUMDNEMR { bits }
-            }
-            #[doc = "Bit 14 - Isochronous OUT packet dropped interrupt mask"]
-            #[inline]
-            pub fn isoodrpm(&self) -> ISOODRPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ISOODRPMR { bits }
-            }
-            #[doc = "Bit 15 - End of periodic frame interrupt mask"]
-            #[inline]
-            pub fn eopfm(&self) -> EOPFMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EOPFMR { bits }
-            }
-            #[doc = "Bit 17 - Endpoint mismatch interrupt mask"]
-            #[inline]
-            pub fn epmism(&self) -> EPMISMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPMISMR { bits }
-            }
-            #[doc = "Bit 18 - IN endpoints interrupt mask"]
-            #[inline]
-            pub fn iepint(&self) -> IEPINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IEPINTR { bits }
-            }
-            #[doc = "Bit 19 - OUT endpoints interrupt mask"]
-            #[inline]
-            pub fn oepint(&self) -> OEPINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OEPINTR { bits }
-            }
-            #[doc = "Bit 20 - Incomplete isochronous IN transfer mask"]
-            #[inline]
-            pub fn iisoixfrm(&self) -> IISOIXFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IISOIXFRMR { bits }
-            }
-            # [ doc = "Bit 21 - Incomplete periodic transfer mask(Host mode)/Incomplete isochronous OUT transfer mask(Device mode)" ] # [ inline ]
-            pub fn ipxfrm_iisooxfrm(&self) -> IPXFRM_IISOOXFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                IPXFRM_IISOOXFRMR { bits }
-            }
-            #[doc = "Bit 24 - Host port interrupt mask"]
-            #[inline]
-            pub fn prtim(&self) -> PRTIMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PRTIMR { bits }
-            }
-            #[doc = "Bit 25 - Host channels interrupt mask"]
-            #[inline]
-            pub fn hcim(&self) -> HCIMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 25;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                HCIMR { bits }
-            }
-            #[doc = "Bit 26 - Periodic TxFIFO empty mask"]
-            #[inline]
-            pub fn ptxfem(&self) -> PTXFEMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PTXFEMR { bits }
-            }
-            #[doc = "Bit 28 - Connector ID status change mask"]
-            #[inline]
-            pub fn cidschgm(&self) -> CIDSCHGMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CIDSCHGMR { bits }
-            }
-            #[doc = "Bit 29 - Disconnect detected interrupt mask"]
-            #[inline]
-            pub fn discint(&self) -> DISCINTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DISCINTR { bits }
-            }
-            #[doc = "Bit 30 - Session request/new session detected interrupt mask"]
-            #[inline]
-            pub fn srqim(&self) -> SRQIMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SRQIMR { bits }
-            }
-            #[doc = "Bit 31 - Resume/remote wakeup detected interrupt mask"]
-            #[inline]
-            pub fn wuim(&self) -> WUIMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WUIMR { bits }
-            }
-        }
-        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 1 - Mode mismatch interrupt mask"]
-            #[inline]
-            pub fn mmism(&mut self) -> _MMISMW {
-                _MMISMW { w: self }
-            }
-            #[doc = "Bit 2 - OTG interrupt mask"]
-            #[inline]
-            pub fn otgint(&mut self) -> _OTGINTW {
-                _OTGINTW { w: self }
-            }
-            #[doc = "Bit 3 - Start of frame mask"]
-            #[inline]
-            pub fn sofm(&mut self) -> _SOFMW {
-                _SOFMW { w: self }
-            }
-            #[doc = "Bit 4 - Receive FIFO non-empty mask"]
-            #[inline]
-            pub fn rxflvlm(&mut self) -> _RXFLVLMW {
-                _RXFLVLMW { w: self }
-            }
-            #[doc = "Bit 5 - Non-periodic TxFIFO empty mask"]
-            #[inline]
-            pub fn nptxfem(&mut self) -> _NPTXFEMW {
-                _NPTXFEMW { w: self }
-            }
-            #[doc = "Bit 6 - Global non-periodic IN NAK effective mask"]
-            #[inline]
-            pub fn ginakeffm(&mut self) -> _GINAKEFFMW {
-                _GINAKEFFMW { w: self }
-            }
-            #[doc = "Bit 7 - Global OUT NAK effective mask"]
-            #[inline]
-            pub fn gonakeffm(&mut self) -> _GONAKEFFMW {
-                _GONAKEFFMW { w: self }
-            }
-            #[doc = "Bit 10 - Early suspend mask"]
-            #[inline]
-            pub fn esuspm(&mut self) -> _ESUSPMW {
-                _ESUSPMW { w: self }
-            }
-            #[doc = "Bit 11 - USB suspend mask"]
-            #[inline]
-            pub fn usbsuspm(&mut self) -> _USBSUSPMW {
-                _USBSUSPMW { w: self }
-            }
-            #[doc = "Bit 12 - USB reset mask"]
-            #[inline]
-            pub fn usbrst(&mut self) -> _USBRSTW {
-                _USBRSTW { w: self }
-            }
-            #[doc = "Bit 13 - Enumeration done mask"]
-            #[inline]
-            pub fn enumdnem(&mut self) -> _ENUMDNEMW {
-                _ENUMDNEMW { w: self }
-            }
-            #[doc = "Bit 14 - Isochronous OUT packet dropped interrupt mask"]
-            #[inline]
-            pub fn isoodrpm(&mut self) -> _ISOODRPMW {
-                _ISOODRPMW { w: self }
-            }
-            #[doc = "Bit 15 - End of periodic frame interrupt mask"]
-            #[inline]
-            pub fn eopfm(&mut self) -> _EOPFMW {
-                _EOPFMW { w: self }
-            }
-            #[doc = "Bit 17 - Endpoint mismatch interrupt mask"]
-            #[inline]
-            pub fn epmism(&mut self) -> _EPMISMW {
-                _EPMISMW { w: self }
-            }
-            #[doc = "Bit 18 - IN endpoints interrupt mask"]
-            #[inline]
-            pub fn iepint(&mut self) -> _IEPINTW {
-                _IEPINTW { w: self }
-            }
-            #[doc = "Bit 19 - OUT endpoints interrupt mask"]
-            #[inline]
-            pub fn oepint(&mut self) -> _OEPINTW {
-                _OEPINTW { w: self }
-            }
-            #[doc = "Bit 20 - Incomplete isochronous IN transfer mask"]
-            #[inline]
-            pub fn iisoixfrm(&mut self) -> _IISOIXFRMW {
-                _IISOIXFRMW { w: self }
-            }
-            # [ doc = "Bit 21 - Incomplete periodic transfer mask(Host mode)/Incomplete isochronous OUT transfer mask(Device mode)" ] # [ inline ]
-            pub fn ipxfrm_iisooxfrm(&mut self) -> _IPXFRM_IISOOXFRMW {
-                _IPXFRM_IISOOXFRMW { w: self }
-            }
-            #[doc = "Bit 25 - Host channels interrupt mask"]
-            #[inline]
-            pub fn hcim(&mut self) -> _HCIMW {
-                _HCIMW { w: self }
-            }
-            #[doc = "Bit 26 - Periodic TxFIFO empty mask"]
-            #[inline]
-            pub fn ptxfem(&mut self) -> _PTXFEMW {
-                _PTXFEMW { w: self }
-            }
-            #[doc = "Bit 28 - Connector ID status change mask"]
-            #[inline]
-            pub fn cidschgm(&mut self) -> _CIDSCHGMW {
-                _CIDSCHGMW { w: self }
-            }
-            #[doc = "Bit 29 - Disconnect detected interrupt mask"]
-            #[inline]
-            pub fn discint(&mut self) -> _DISCINTW {
-                _DISCINTW { w: self }
-            }
-            #[doc = "Bit 30 - Session request/new session detected interrupt mask"]
-            #[inline]
-            pub fn srqim(&mut self) -> _SRQIMW {
-                _SRQIMW { w: self }
-            }
-            #[doc = "Bit 31 - Resume/remote wakeup detected interrupt mask"]
-            #[inline]
-            pub fn wuim(&mut self) -> _WUIMW {
-                _WUIMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS Receive status debug read(Device mode)"]
-    pub struct FS_GRXSTSR_DEVICE {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS Receive status debug read(Device mode)"]
-    pub mod fs_grxstsr_device {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FS_GRXSTSR_DEVICE {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BCNTR {
-            bits: u16,
-        }
-        impl BCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTSTSR {
-            bits: u8,
-        }
-        impl PKTSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FRMNUMR {
-            bits: u8,
-        }
-        impl FRMNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:3 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bits 4:14 - Byte count"]
-            #[inline]
-            pub fn bcnt(&self) -> BCNTR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                BCNTR { bits }
-            }
-            #[doc = "Bits 15:16 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-            #[doc = "Bits 17:20 - Packet status"]
-            #[inline]
-            pub fn pktsts(&self) -> PKTSTSR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PKTSTSR { bits }
-            }
-            #[doc = "Bits 21:24 - Frame number"]
-            #[inline]
-            pub fn frmnum(&self) -> FRMNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FRMNUMR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS Receive status debug read(Host mode)"]
-    pub struct FS_GRXSTSR_HOST {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS Receive status debug read(Host mode)"]
-    pub mod fs_grxstsr_host {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FS_GRXSTSR_HOST {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BCNTR {
-            bits: u16,
-        }
-        impl BCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTSTSR {
-            bits: u8,
-        }
-        impl PKTSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FRMNUMR {
-            bits: u8,
-        }
-        impl FRMNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:3 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bits 4:14 - Byte count"]
-            #[inline]
-            pub fn bcnt(&self) -> BCNTR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                BCNTR { bits }
-            }
-            #[doc = "Bits 15:16 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-            #[doc = "Bits 17:20 - Packet status"]
-            #[inline]
-            pub fn pktsts(&self) -> PKTSTSR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PKTSTSR { bits }
-            }
-            #[doc = "Bits 21:24 - Frame number"]
-            #[inline]
-            pub fn frmnum(&self) -> FRMNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FRMNUMR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS Receive FIFO size register (OTG_FS_GRXFSIZ)"]
-    pub struct FS_GRXFSIZ {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS Receive FIFO size register (OTG_FS_GRXFSIZ)"]
-    pub mod fs_grxfsiz {
-        #[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::FS_GRXFSIZ {
-            #[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 = r" Value of the field"]
-        pub struct RXFDR {
-            bits: u16,
-        }
-        impl RXFDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RXFDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXFDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - RxFIFO depth"]
-            #[inline]
-            pub fn rxfd(&self) -> RXFDR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                RXFDR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0200 }
-            }
-            #[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 0:15 - RxFIFO depth"]
-            #[inline]
-            pub fn rxfd(&mut self) -> _RXFDW {
-                _RXFDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS non-periodic transmit FIFO size register (Device mode)"]
-    pub struct FS_GNPTXFSIZ_DEVICE {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS non-periodic transmit FIFO size register (Device mode)"]
-    pub mod fs_gnptxfsiz_device {
-        #[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::FS_GNPTXFSIZ_DEVICE {
-            #[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 = r" Value of the field"]
-        pub struct TX0FSAR {
-            bits: u16,
-        }
-        impl TX0FSAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TX0FDR {
-            bits: u16,
-        }
-        impl TX0FDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TX0FSAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TX0FSAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TX0FDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TX0FDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                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 0:15 - Endpoint 0 transmit RAM start address"]
-            #[inline]
-            pub fn tx0fsa(&self) -> TX0FSAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TX0FSAR { bits }
-            }
-            #[doc = "Bits 16:31 - Endpoint 0 TxFIFO depth"]
-            #[inline]
-            pub fn tx0fd(&self) -> TX0FDR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TX0FDR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0200 }
-            }
-            #[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 0:15 - Endpoint 0 transmit RAM start address"]
-            #[inline]
-            pub fn tx0fsa(&mut self) -> _TX0FSAW {
-                _TX0FSAW { w: self }
-            }
-            #[doc = "Bits 16:31 - Endpoint 0 TxFIFO depth"]
-            #[inline]
-            pub fn tx0fd(&mut self) -> _TX0FDW {
-                _TX0FDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS non-periodic transmit FIFO size register (Host mode)"]
-    pub struct FS_GNPTXFSIZ_HOST {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS non-periodic transmit FIFO size register (Host mode)"]
-    pub mod fs_gnptxfsiz_host {
-        #[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::FS_GNPTXFSIZ_HOST {
-            #[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 = r" Value of the field"]
-        pub struct NPTXFSAR {
-            bits: u16,
-        }
-        impl NPTXFSAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NPTXFDR {
-            bits: u16,
-        }
-        impl NPTXFDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NPTXFSAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NPTXFSAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NPTXFDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NPTXFDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                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 0:15 - Non-periodic transmit RAM start address"]
-            #[inline]
-            pub fn nptxfsa(&self) -> NPTXFSAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NPTXFSAR { bits }
-            }
-            #[doc = "Bits 16:31 - Non-periodic TxFIFO depth"]
-            #[inline]
-            pub fn nptxfd(&self) -> NPTXFDR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NPTXFDR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0200 }
-            }
-            #[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 0:15 - Non-periodic transmit RAM start address"]
-            #[inline]
-            pub fn nptxfsa(&mut self) -> _NPTXFSAW {
-                _NPTXFSAW { w: self }
-            }
-            #[doc = "Bits 16:31 - Non-periodic TxFIFO depth"]
-            #[inline]
-            pub fn nptxfd(&mut self) -> _NPTXFDW {
-                _NPTXFDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS non-periodic transmit FIFO/queue status register (OTG_FS_GNPTXSTS)"]
-    pub struct FS_GNPTXSTS {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS non-periodic transmit FIFO/queue status register (OTG_FS_GNPTXSTS)"]
-    pub mod fs_gnptxsts {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FS_GNPTXSTS {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NPTXFSAVR {
-            bits: u16,
-        }
-        impl NPTXFSAVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NPTQXSAVR {
-            bits: u8,
-        }
-        impl NPTQXSAVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NPTXQTOPR {
-            bits: u8,
-        }
-        impl NPTXQTOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Non-periodic TxFIFO space available"]
-            #[inline]
-            pub fn nptxfsav(&self) -> NPTXFSAVR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                NPTXFSAVR { bits }
-            }
-            #[doc = "Bits 16:23 - Non-periodic transmit request queue space available"]
-            #[inline]
-            pub fn nptqxsav(&self) -> NPTQXSAVR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                NPTQXSAVR { bits }
-            }
-            #[doc = "Bits 24:30 - Top of the non-periodic transmit request queue"]
-            #[inline]
-            pub fn nptxqtop(&self) -> NPTXQTOPR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                NPTXQTOPR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS general core configuration register (OTG_FS_GCCFG)"]
-    pub struct FS_GCCFG {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS general core configuration register (OTG_FS_GCCFG)"]
-    pub mod fs_gccfg {
-        #[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::FS_GCCFG {
-            #[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 = r" Value of the field"]
-        pub struct DCDETR {
-            bits: bool,
-        }
-        impl DCDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PDETR {
-            bits: bool,
-        }
-        impl PDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDETR {
-            bits: bool,
-        }
-        impl SDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PS2DETR {
-            bits: bool,
-        }
-        impl PS2DETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PWRDWNR {
-            bits: bool,
-        }
-        impl PWRDWNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BCDENR {
-            bits: bool,
-        }
-        impl BCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DCDENR {
-            bits: bool,
-        }
-        impl DCDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PDENR {
-            bits: bool,
-        }
-        impl PDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDENR {
-            bits: bool,
-        }
-        impl SDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct VBDENR {
-            bits: bool,
-        }
-        impl VBDENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _DCDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PS2DETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PS2DETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PWRDWNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PWRDWNW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DCDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _VBDENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _VBDENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - DCDET"]
-            #[inline]
-            pub fn dcdet(&self) -> DCDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCDETR { bits }
-            }
-            #[doc = "Bit 1 - PDET"]
-            #[inline]
-            pub fn pdet(&self) -> PDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PDETR { bits }
-            }
-            #[doc = "Bit 2 - SDET"]
-            #[inline]
-            pub fn sdet(&self) -> SDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDETR { bits }
-            }
-            #[doc = "Bit 3 - PS2DET"]
-            #[inline]
-            pub fn ps2det(&self) -> PS2DETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PS2DETR { bits }
-            }
-            #[doc = "Bit 16 - PWRDWN"]
-            #[inline]
-            pub fn pwrdwn(&self) -> PWRDWNR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PWRDWNR { bits }
-            }
-            #[doc = "Bit 17 - BCDEN"]
-            #[inline]
-            pub fn bcden(&self) -> BCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BCDENR { bits }
-            }
-            #[doc = "Bit 18 - DCDEN"]
-            #[inline]
-            pub fn dcden(&self) -> DCDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DCDENR { bits }
-            }
-            #[doc = "Bit 19 - PDEN"]
-            #[inline]
-            pub fn pden(&self) -> PDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PDENR { bits }
-            }
-            #[doc = "Bit 20 - SDEN"]
-            #[inline]
-            pub fn sden(&self) -> SDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDENR { bits }
-            }
-            #[doc = "Bit 21 - VBDEN"]
-            #[inline]
-            pub fn vbden(&self) -> VBDENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                VBDENR { bits }
-            }
-        }
-        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 - DCDET"]
-            #[inline]
-            pub fn dcdet(&mut self) -> _DCDETW {
-                _DCDETW { w: self }
-            }
-            #[doc = "Bit 1 - PDET"]
-            #[inline]
-            pub fn pdet(&mut self) -> _PDETW {
-                _PDETW { w: self }
-            }
-            #[doc = "Bit 2 - SDET"]
-            #[inline]
-            pub fn sdet(&mut self) -> _SDETW {
-                _SDETW { w: self }
-            }
-            #[doc = "Bit 3 - PS2DET"]
-            #[inline]
-            pub fn ps2det(&mut self) -> _PS2DETW {
-                _PS2DETW { w: self }
-            }
-            #[doc = "Bit 16 - PWRDWN"]
-            #[inline]
-            pub fn pwrdwn(&mut self) -> _PWRDWNW {
-                _PWRDWNW { w: self }
-            }
-            #[doc = "Bit 17 - BCDEN"]
-            #[inline]
-            pub fn bcden(&mut self) -> _BCDENW {
-                _BCDENW { w: self }
-            }
-            #[doc = "Bit 18 - DCDEN"]
-            #[inline]
-            pub fn dcden(&mut self) -> _DCDENW {
-                _DCDENW { w: self }
-            }
-            #[doc = "Bit 19 - PDEN"]
-            #[inline]
-            pub fn pden(&mut self) -> _PDENW {
-                _PDENW { w: self }
-            }
-            #[doc = "Bit 20 - SDEN"]
-            #[inline]
-            pub fn sden(&mut self) -> _SDENW {
-                _SDENW { w: self }
-            }
-            #[doc = "Bit 21 - VBDEN"]
-            #[inline]
-            pub fn vbden(&mut self) -> _VBDENW {
-                _VBDENW { w: self }
-            }
-        }
-    }
-    #[doc = "core ID register"]
-    pub struct FS_CID {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "core ID register"]
-    pub mod fs_cid {
-        #[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::FS_CID {
-            #[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 = r" Value of the field"]
-        pub struct PRODUCT_IDR {
-            bits: u32,
-        }
-        impl PRODUCT_IDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PRODUCT_IDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRODUCT_IDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Product ID field"]
-            #[inline]
-            pub fn product_id(&self) -> PRODUCT_IDR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                PRODUCT_IDR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x1000 }
-            }
-            #[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 0:31 - Product ID field"]
-            #[inline]
-            pub fn product_id(&mut self) -> _PRODUCT_IDW {
-                _PRODUCT_IDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS Host periodic transmit FIFO size register (OTG_FS_HPTXFSIZ)"]
-    pub struct FS_HPTXFSIZ {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS Host periodic transmit FIFO size register (OTG_FS_HPTXFSIZ)"]
-    pub mod fs_hptxfsiz {
-        #[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::FS_HPTXFSIZ {
-            #[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 = r" Value of the field"]
-        pub struct PTXSAR {
-            bits: u16,
-        }
-        impl PTXSAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PTXFSIZR {
-            bits: u16,
-        }
-        impl PTXFSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PTXSAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTXSAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PTXFSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTXFSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                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 0:15 - Host periodic TxFIFO start address"]
-            #[inline]
-            pub fn ptxsa(&self) -> PTXSAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PTXSAR { bits }
-            }
-            #[doc = "Bits 16:31 - Host periodic TxFIFO depth"]
-            #[inline]
-            pub fn ptxfsiz(&self) -> PTXFSIZR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PTXFSIZR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0200_0600 }
-            }
-            #[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 0:15 - Host periodic TxFIFO start address"]
-            #[inline]
-            pub fn ptxsa(&mut self) -> _PTXSAW {
-                _PTXSAW { w: self }
-            }
-            #[doc = "Bits 16:31 - Host periodic TxFIFO depth"]
-            #[inline]
-            pub fn ptxfsiz(&mut self) -> _PTXFSIZW {
-                _PTXFSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF2)"]
-    pub struct FS_DIEPTXF1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF2)"]
-    pub mod fs_dieptxf1 {
-        #[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::FS_DIEPTXF1 {
-            #[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 = r" Value of the field"]
-        pub struct INEPTXSAR {
-            bits: u16,
-        }
-        impl INEPTXSAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INEPTXFDR {
-            bits: u16,
-        }
-        impl INEPTXFDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INEPTXSAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPTXSAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INEPTXFDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPTXFDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                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 0:15 - IN endpoint FIFO2 transmit RAM start address"]
-            #[inline]
-            pub fn ineptxsa(&self) -> INEPTXSAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTXSAR { bits }
-            }
-            #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"]
-            #[inline]
-            pub fn ineptxfd(&self) -> INEPTXFDR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTXFDR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0200_0400 }
-            }
-            #[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 0:15 - IN endpoint FIFO2 transmit RAM start address"]
-            #[inline]
-            pub fn ineptxsa(&mut self) -> _INEPTXSAW {
-                _INEPTXSAW { w: self }
-            }
-            #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"]
-            #[inline]
-            pub fn ineptxfd(&mut self) -> _INEPTXFDW {
-                _INEPTXFDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF3)"]
-    pub struct FS_DIEPTXF2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF3)"]
-    pub mod fs_dieptxf2 {
-        #[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::FS_DIEPTXF2 {
-            #[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 = r" Value of the field"]
-        pub struct INEPTXSAR {
-            bits: u16,
-        }
-        impl INEPTXSAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INEPTXFDR {
-            bits: u16,
-        }
-        impl INEPTXFDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INEPTXSAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPTXSAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INEPTXFDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPTXFDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                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 0:15 - IN endpoint FIFO3 transmit RAM start address"]
-            #[inline]
-            pub fn ineptxsa(&self) -> INEPTXSAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTXSAR { bits }
-            }
-            #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"]
-            #[inline]
-            pub fn ineptxfd(&self) -> INEPTXFDR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTXFDR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0200_0400 }
-            }
-            #[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 0:15 - IN endpoint FIFO3 transmit RAM start address"]
-            #[inline]
-            pub fn ineptxsa(&mut self) -> _INEPTXSAW {
-                _INEPTXSAW { w: self }
-            }
-            #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"]
-            #[inline]
-            pub fn ineptxfd(&mut self) -> _INEPTXFDW {
-                _INEPTXFDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF4)"]
-    pub struct FS_DIEPTXF3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF4)"]
-    pub mod fs_dieptxf3 {
-        #[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::FS_DIEPTXF3 {
-            #[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 = r" Value of the field"]
-        pub struct INEPTXSAR {
-            bits: u16,
-        }
-        impl INEPTXSAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INEPTXFDR {
-            bits: u16,
-        }
-        impl INEPTXFDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INEPTXSAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPTXSAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INEPTXFDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPTXFDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                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 0:15 - IN endpoint FIFO4 transmit RAM start address"]
-            #[inline]
-            pub fn ineptxsa(&self) -> INEPTXSAR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTXSAR { bits }
-            }
-            #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"]
-            #[inline]
-            pub fn ineptxfd(&self) -> INEPTXFDR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTXFDR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0200_0400 }
-            }
-            #[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 0:15 - IN endpoint FIFO4 transmit RAM start address"]
-            #[inline]
-            pub fn ineptxsa(&mut self) -> _INEPTXSAW {
-                _INEPTXSAW { w: self }
-            }
-            #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"]
-            #[inline]
-            pub fn ineptxfd(&mut self) -> _INEPTXFDW {
-                _INEPTXFDW { w: self }
-            }
-        }
-    }
-}
-#[doc = "USB on the go full speed"]
-pub struct OTG_FS_HOST {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for OTG_FS_HOST {}
-impl OTG_FS_HOST {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const otg_fs_host::RegisterBlock {
-        0x5000_0400 as *const _
-    }
-}
-impl Deref for OTG_FS_HOST {
-    type Target = otg_fs_host::RegisterBlock;
-    fn deref(&self) -> &otg_fs_host::RegisterBlock {
-        unsafe { &*OTG_FS_HOST::ptr() }
-    }
-}
-#[doc = "USB on the go full speed"]
-pub mod otg_fs_host {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - OTG_FS host configuration register (OTG_FS_HCFG)"]
-        pub fs_hcfg: FS_HCFG,
-        #[doc = "0x04 - OTG_FS Host frame interval register"]
-        pub hfir: HFIR,
-        #[doc = "0x08 - OTG_FS host frame number/frame time remaining register (OTG_FS_HFNUM)"]
-        pub fs_hfnum: FS_HFNUM,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x10 - OTG_FS_Host periodic transmit FIFO/queue status register (OTG_FS_HPTXSTS)"]
-        pub fs_hptxsts: FS_HPTXSTS,
-        #[doc = "0x14 - OTG_FS Host all channels interrupt register"]
-        pub haint: HAINT,
-        #[doc = "0x18 - OTG_FS host all channels interrupt mask register"]
-        pub haintmsk: HAINTMSK,
-        _reserved1: [u8; 36usize],
-        #[doc = "0x40 - OTG_FS host port control and status register (OTG_FS_HPRT)"]
-        pub fs_hprt: FS_HPRT,
-        _reserved2: [u8; 188usize],
-        #[doc = "0x100 - OTG_FS host channel-0 characteristics register (OTG_FS_HCCHAR0)"]
-        pub fs_hcchar0: FS_HCCHAR0,
-        _reserved3: [u8; 4usize],
-        #[doc = "0x108 - OTG_FS host channel-0 interrupt register (OTG_FS_HCINT0)"]
-        pub fs_hcint0: FS_HCINT0,
-        #[doc = "0x10c - OTG_FS host channel-0 mask register (OTG_FS_HCINTMSK0)"]
-        pub fs_hcintmsk0: FS_HCINTMSK0,
-        #[doc = "0x110 - OTG_FS host channel-0 transfer size register"]
-        pub fs_hctsiz0: FS_HCTSIZ0,
-        _reserved4: [u8; 12usize],
-        #[doc = "0x120 - OTG_FS host channel-1 characteristics register (OTG_FS_HCCHAR1)"]
-        pub fs_hcchar1: FS_HCCHAR1,
-        _reserved5: [u8; 4usize],
-        #[doc = "0x128 - OTG_FS host channel-1 interrupt register (OTG_FS_HCINT1)"]
-        pub fs_hcint1: FS_HCINT1,
-        #[doc = "0x12c - OTG_FS host channel-1 mask register (OTG_FS_HCINTMSK1)"]
-        pub fs_hcintmsk1: FS_HCINTMSK1,
-        #[doc = "0x130 - OTG_FS host channel-1 transfer size register"]
-        pub fs_hctsiz1: FS_HCTSIZ1,
-        _reserved6: [u8; 12usize],
-        #[doc = "0x140 - OTG_FS host channel-2 characteristics register (OTG_FS_HCCHAR2)"]
-        pub fs_hcchar2: FS_HCCHAR2,
-        _reserved7: [u8; 4usize],
-        #[doc = "0x148 - OTG_FS host channel-2 interrupt register (OTG_FS_HCINT2)"]
-        pub fs_hcint2: FS_HCINT2,
-        #[doc = "0x14c - OTG_FS host channel-2 mask register (OTG_FS_HCINTMSK2)"]
-        pub fs_hcintmsk2: FS_HCINTMSK2,
-        #[doc = "0x150 - OTG_FS host channel-2 transfer size register"]
-        pub fs_hctsiz2: FS_HCTSIZ2,
-        _reserved8: [u8; 12usize],
-        #[doc = "0x160 - OTG_FS host channel-3 characteristics register (OTG_FS_HCCHAR3)"]
-        pub fs_hcchar3: FS_HCCHAR3,
-        _reserved9: [u8; 4usize],
-        #[doc = "0x168 - OTG_FS host channel-3 interrupt register (OTG_FS_HCINT3)"]
-        pub fs_hcint3: FS_HCINT3,
-        #[doc = "0x16c - OTG_FS host channel-3 mask register (OTG_FS_HCINTMSK3)"]
-        pub fs_hcintmsk3: FS_HCINTMSK3,
-        #[doc = "0x170 - OTG_FS host channel-3 transfer size register"]
-        pub fs_hctsiz3: FS_HCTSIZ3,
-        _reserved10: [u8; 12usize],
-        #[doc = "0x180 - OTG_FS host channel-4 characteristics register (OTG_FS_HCCHAR4)"]
-        pub fs_hcchar4: FS_HCCHAR4,
-        _reserved11: [u8; 4usize],
-        #[doc = "0x188 - OTG_FS host channel-4 interrupt register (OTG_FS_HCINT4)"]
-        pub fs_hcint4: FS_HCINT4,
-        #[doc = "0x18c - OTG_FS host channel-4 mask register (OTG_FS_HCINTMSK4)"]
-        pub fs_hcintmsk4: FS_HCINTMSK4,
-        #[doc = "0x190 - OTG_FS host channel-x transfer size register"]
-        pub fs_hctsiz4: FS_HCTSIZ4,
-        _reserved12: [u8; 12usize],
-        #[doc = "0x1a0 - OTG_FS host channel-5 characteristics register (OTG_FS_HCCHAR5)"]
-        pub fs_hcchar5: FS_HCCHAR5,
-        _reserved13: [u8; 4usize],
-        #[doc = "0x1a8 - OTG_FS host channel-5 interrupt register (OTG_FS_HCINT5)"]
-        pub fs_hcint5: FS_HCINT5,
-        #[doc = "0x1ac - OTG_FS host channel-5 mask register (OTG_FS_HCINTMSK5)"]
-        pub fs_hcintmsk5: FS_HCINTMSK5,
-        #[doc = "0x1b0 - OTG_FS host channel-5 transfer size register"]
-        pub fs_hctsiz5: FS_HCTSIZ5,
-        _reserved14: [u8; 12usize],
-        #[doc = "0x1c0 - OTG_FS host channel-6 characteristics register (OTG_FS_HCCHAR6)"]
-        pub fs_hcchar6: FS_HCCHAR6,
-        _reserved15: [u8; 4usize],
-        #[doc = "0x1c8 - OTG_FS host channel-6 interrupt register (OTG_FS_HCINT6)"]
-        pub fs_hcint6: FS_HCINT6,
-        #[doc = "0x1cc - OTG_FS host channel-6 mask register (OTG_FS_HCINTMSK6)"]
-        pub fs_hcintmsk6: FS_HCINTMSK6,
-        #[doc = "0x1d0 - OTG_FS host channel-6 transfer size register"]
-        pub fs_hctsiz6: FS_HCTSIZ6,
-        _reserved16: [u8; 12usize],
-        #[doc = "0x1e0 - OTG_FS host channel-7 characteristics register (OTG_FS_HCCHAR7)"]
-        pub fs_hcchar7: FS_HCCHAR7,
-        _reserved17: [u8; 4usize],
-        #[doc = "0x1e8 - OTG_FS host channel-7 interrupt register (OTG_FS_HCINT7)"]
-        pub fs_hcint7: FS_HCINT7,
-        #[doc = "0x1ec - OTG_FS host channel-7 mask register (OTG_FS_HCINTMSK7)"]
-        pub fs_hcintmsk7: FS_HCINTMSK7,
-        #[doc = "0x1f0 - OTG_FS host channel-7 transfer size register"]
-        pub fs_hctsiz7: FS_HCTSIZ7,
-    }
-    #[doc = "OTG_FS host configuration register (OTG_FS_HCFG)"]
-    pub struct FS_HCFG {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host configuration register (OTG_FS_HCFG)"]
-    pub mod fs_hcfg {
-        #[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::FS_HCFG {
-            #[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 = r" Value of the field"]
-        pub struct FSLSPCSR {
-            bits: u8,
-        }
-        impl FSLSPCSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FSLSSR {
-            bits: bool,
-        }
-        impl FSLSSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FSLSPCSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSLSPCSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 0:1 - FS/LS PHY clock select"]
-            #[inline]
-            pub fn fslspcs(&self) -> FSLSPCSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSLSPCSR { bits }
-            }
-            #[doc = "Bit 2 - FS- and LS-only support"]
-            #[inline]
-            pub fn fslss(&self) -> FSLSSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSLSSR { bits }
-            }
-        }
-        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 0:1 - FS/LS PHY clock select"]
-            #[inline]
-            pub fn fslspcs(&mut self) -> _FSLSPCSW {
-                _FSLSPCSW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS Host frame interval register"]
-    pub struct HFIR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS Host frame interval register"]
-    pub mod hfir {
-        #[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::HFIR {
-            #[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 = r" Value of the field"]
-        pub struct FRIVLR {
-            bits: u16,
-        }
-        impl FRIVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FRIVLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRIVLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Frame interval"]
-            #[inline]
-            pub fn frivl(&self) -> FRIVLR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                FRIVLR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0xea60 }
-            }
-            #[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 0:15 - Frame interval"]
-            #[inline]
-            pub fn frivl(&mut self) -> _FRIVLW {
-                _FRIVLW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host frame number/frame time remaining register (OTG_FS_HFNUM)"]
-    pub struct FS_HFNUM {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host frame number/frame time remaining register (OTG_FS_HFNUM)"]
-    pub mod fs_hfnum {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FS_HFNUM {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FRNUMR {
-            bits: u16,
-        }
-        impl FRNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FTREMR {
-            bits: u16,
-        }
-        impl FTREMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Frame number"]
-            #[inline]
-            pub fn frnum(&self) -> FRNUMR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                FRNUMR { bits }
-            }
-            #[doc = "Bits 16:31 - Frame time remaining"]
-            #[inline]
-            pub fn ftrem(&self) -> FTREMR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                FTREMR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS_Host periodic transmit FIFO/queue status register (OTG_FS_HPTXSTS)"]
-    pub struct FS_HPTXSTS {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS_Host periodic transmit FIFO/queue status register (OTG_FS_HPTXSTS)"]
-    pub mod fs_hptxsts {
-        #[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::FS_HPTXSTS {
-            #[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 = r" Value of the field"]
-        pub struct PTXFSAVLR {
-            bits: u16,
-        }
-        impl PTXFSAVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PTXQSAVR {
-            bits: u8,
-        }
-        impl PTXQSAVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PTXQTOPR {
-            bits: u8,
-        }
-        impl PTXQTOPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PTXFSAVLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTXFSAVLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Periodic transmit data FIFO space available"]
-            #[inline]
-            pub fn ptxfsavl(&self) -> PTXFSAVLR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PTXFSAVLR { bits }
-            }
-            #[doc = "Bits 16:23 - Periodic transmit request queue space available"]
-            #[inline]
-            pub fn ptxqsav(&self) -> PTXQSAVR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PTXQSAVR { bits }
-            }
-            #[doc = "Bits 24:31 - Top of the periodic transmit request queue"]
-            #[inline]
-            pub fn ptxqtop(&self) -> PTXQTOPR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PTXQTOPR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0008_0100 }
-            }
-            #[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 0:15 - Periodic transmit data FIFO space available"]
-            #[inline]
-            pub fn ptxfsavl(&mut self) -> _PTXFSAVLW {
-                _PTXFSAVLW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS Host all channels interrupt register"]
-    pub struct HAINT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS Host all channels interrupt register"]
-    pub mod haint {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::HAINT {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct HAINTR {
-            bits: u16,
-        }
-        impl HAINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Channel interrupts"]
-            #[inline]
-            pub fn haint(&self) -> HAINTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                HAINTR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS host all channels interrupt mask register"]
-    pub struct HAINTMSK {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host all channels interrupt mask register"]
-    pub mod haintmsk {
-        #[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::HAINTMSK {
-            #[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 = r" Value of the field"]
-        pub struct HAINTMR {
-            bits: u16,
-        }
-        impl HAINTMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _HAINTMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _HAINTMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Channel interrupt mask"]
-            #[inline]
-            pub fn haintm(&self) -> HAINTMR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                HAINTMR { bits }
-            }
-        }
-        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 0:15 - Channel interrupt mask"]
-            #[inline]
-            pub fn haintm(&mut self) -> _HAINTMW {
-                _HAINTMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host port control and status register (OTG_FS_HPRT)"]
-    pub struct FS_HPRT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host port control and status register (OTG_FS_HPRT)"]
-    pub mod fs_hprt {
-        #[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::FS_HPRT {
-            #[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 = r" Value of the field"]
-        pub struct PCSTSR {
-            bits: bool,
-        }
-        impl PCSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PCDETR {
-            bits: bool,
-        }
-        impl PCDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PENAR {
-            bits: bool,
-        }
-        impl PENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PENCHNGR {
-            bits: bool,
-        }
-        impl PENCHNGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct POCAR {
-            bits: bool,
-        }
-        impl POCAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct POCCHNGR {
-            bits: bool,
-        }
-        impl POCCHNGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PRESR {
-            bits: bool,
-        }
-        impl PRESR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PSUSPR {
-            bits: bool,
-        }
-        impl PSUSPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PRSTR {
-            bits: bool,
-        }
-        impl PRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PLSTSR {
-            bits: u8,
-        }
-        impl PLSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PPWRR {
-            bits: bool,
-        }
-        impl PPWRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PTCTLR {
-            bits: u8,
-        }
-        impl PTCTLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PSPDR {
-            bits: u8,
-        }
-        impl PSPDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PCDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PCDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PENAW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PENCHNGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PENCHNGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _POCCHNGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _POCCHNGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PRESW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRESW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PSUSPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PSUSPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PPWRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PPWRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PTCTLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PTCTLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 13;
-                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 - Port connect status"]
-            #[inline]
-            pub fn pcsts(&self) -> PCSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PCSTSR { bits }
-            }
-            #[doc = "Bit 1 - Port connect detected"]
-            #[inline]
-            pub fn pcdet(&self) -> PCDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PCDETR { bits }
-            }
-            #[doc = "Bit 2 - Port enable"]
-            #[inline]
-            pub fn pena(&self) -> PENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PENAR { bits }
-            }
-            #[doc = "Bit 3 - Port enable/disable change"]
-            #[inline]
-            pub fn penchng(&self) -> PENCHNGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PENCHNGR { bits }
-            }
-            #[doc = "Bit 4 - Port overcurrent active"]
-            #[inline]
-            pub fn poca(&self) -> POCAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                POCAR { bits }
-            }
-            #[doc = "Bit 5 - Port overcurrent change"]
-            #[inline]
-            pub fn pocchng(&self) -> POCCHNGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                POCCHNGR { bits }
-            }
-            #[doc = "Bit 6 - Port resume"]
-            #[inline]
-            pub fn pres(&self) -> PRESR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PRESR { bits }
-            }
-            #[doc = "Bit 7 - Port suspend"]
-            #[inline]
-            pub fn psusp(&self) -> PSUSPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PSUSPR { bits }
-            }
-            #[doc = "Bit 8 - Port reset"]
-            #[inline]
-            pub fn prst(&self) -> PRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PRSTR { bits }
-            }
-            #[doc = "Bits 10:11 - Port line status"]
-            #[inline]
-            pub fn plsts(&self) -> PLSTSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PLSTSR { bits }
-            }
-            #[doc = "Bit 12 - Port power"]
-            #[inline]
-            pub fn ppwr(&self) -> PPWRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PPWRR { bits }
-            }
-            #[doc = "Bits 13:16 - Port test control"]
-            #[inline]
-            pub fn ptctl(&self) -> PTCTLR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PTCTLR { bits }
-            }
-            #[doc = "Bits 17:18 - Port speed"]
-            #[inline]
-            pub fn pspd(&self) -> PSPDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PSPDR { bits }
-            }
-        }
-        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 1 - Port connect detected"]
-            #[inline]
-            pub fn pcdet(&mut self) -> _PCDETW {
-                _PCDETW { w: self }
-            }
-            #[doc = "Bit 2 - Port enable"]
-            #[inline]
-            pub fn pena(&mut self) -> _PENAW {
-                _PENAW { w: self }
-            }
-            #[doc = "Bit 3 - Port enable/disable change"]
-            #[inline]
-            pub fn penchng(&mut self) -> _PENCHNGW {
-                _PENCHNGW { w: self }
-            }
-            #[doc = "Bit 5 - Port overcurrent change"]
-            #[inline]
-            pub fn pocchng(&mut self) -> _POCCHNGW {
-                _POCCHNGW { w: self }
-            }
-            #[doc = "Bit 6 - Port resume"]
-            #[inline]
-            pub fn pres(&mut self) -> _PRESW {
-                _PRESW { w: self }
-            }
-            #[doc = "Bit 7 - Port suspend"]
-            #[inline]
-            pub fn psusp(&mut self) -> _PSUSPW {
-                _PSUSPW { w: self }
-            }
-            #[doc = "Bit 8 - Port reset"]
-            #[inline]
-            pub fn prst(&mut self) -> _PRSTW {
-                _PRSTW { w: self }
-            }
-            #[doc = "Bit 12 - Port power"]
-            #[inline]
-            pub fn ppwr(&mut self) -> _PPWRW {
-                _PPWRW { w: self }
-            }
-            #[doc = "Bits 13:16 - Port test control"]
-            #[inline]
-            pub fn ptctl(&mut self) -> _PTCTLW {
-                _PTCTLW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-0 characteristics register (OTG_FS_HCCHAR0)"]
-    pub struct FS_HCCHAR0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-0 characteristics register (OTG_FS_HCCHAR0)"]
-    pub mod fs_hcchar0 {
-        #[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::FS_HCCHAR0 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDIRR {
-            bits: bool,
-        }
-        impl EPDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSDEVR {
-            bits: bool,
-        }
-        impl LSDEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ODDFRMR {
-            bits: bool,
-        }
-        impl ODDFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHDISR {
-            bits: bool,
-        }
-        impl CHDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENAR {
-            bits: bool,
-        }
-        impl CHENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSDEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSDEVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENAW<'a> {
-            #[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 = "Bits 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&self) -> EPDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDIRR { bits }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&self) -> LSDEVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSDEVR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&self) -> ODDFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDFRMR { bits }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&self) -> CHDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHDISR { bits }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&self) -> CHENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENAR { bits }
-            }
-        }
-        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 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&mut self) -> _EPNUMW {
-                _EPNUMW { w: self }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&mut self) -> _EPDIRW {
-                _EPDIRW { w: self }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&mut self) -> _LSDEVW {
-                _LSDEVW { w: self }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&mut self) -> _ODDFRMW {
-                _ODDFRMW { w: self }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&mut self) -> _CHDISW {
-                _CHDISW { w: self }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&mut self) -> _CHENAW {
-                _CHENAW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-1 characteristics register (OTG_FS_HCCHAR1)"]
-    pub struct FS_HCCHAR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-1 characteristics register (OTG_FS_HCCHAR1)"]
-    pub mod fs_hcchar1 {
-        #[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::FS_HCCHAR1 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDIRR {
-            bits: bool,
-        }
-        impl EPDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSDEVR {
-            bits: bool,
-        }
-        impl LSDEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ODDFRMR {
-            bits: bool,
-        }
-        impl ODDFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHDISR {
-            bits: bool,
-        }
-        impl CHDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENAR {
-            bits: bool,
-        }
-        impl CHENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSDEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSDEVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENAW<'a> {
-            #[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 = "Bits 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&self) -> EPDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDIRR { bits }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&self) -> LSDEVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSDEVR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&self) -> ODDFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDFRMR { bits }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&self) -> CHDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHDISR { bits }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&self) -> CHENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENAR { bits }
-            }
-        }
-        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 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&mut self) -> _EPNUMW {
-                _EPNUMW { w: self }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&mut self) -> _EPDIRW {
-                _EPDIRW { w: self }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&mut self) -> _LSDEVW {
-                _LSDEVW { w: self }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&mut self) -> _ODDFRMW {
-                _ODDFRMW { w: self }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&mut self) -> _CHDISW {
-                _CHDISW { w: self }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&mut self) -> _CHENAW {
-                _CHENAW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-2 characteristics register (OTG_FS_HCCHAR2)"]
-    pub struct FS_HCCHAR2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-2 characteristics register (OTG_FS_HCCHAR2)"]
-    pub mod fs_hcchar2 {
-        #[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::FS_HCCHAR2 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDIRR {
-            bits: bool,
-        }
-        impl EPDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSDEVR {
-            bits: bool,
-        }
-        impl LSDEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ODDFRMR {
-            bits: bool,
-        }
-        impl ODDFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHDISR {
-            bits: bool,
-        }
-        impl CHDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENAR {
-            bits: bool,
-        }
-        impl CHENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSDEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSDEVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENAW<'a> {
-            #[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 = "Bits 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&self) -> EPDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDIRR { bits }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&self) -> LSDEVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSDEVR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&self) -> ODDFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDFRMR { bits }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&self) -> CHDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHDISR { bits }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&self) -> CHENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENAR { bits }
-            }
-        }
-        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 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&mut self) -> _EPNUMW {
-                _EPNUMW { w: self }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&mut self) -> _EPDIRW {
-                _EPDIRW { w: self }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&mut self) -> _LSDEVW {
-                _LSDEVW { w: self }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&mut self) -> _ODDFRMW {
-                _ODDFRMW { w: self }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&mut self) -> _CHDISW {
-                _CHDISW { w: self }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&mut self) -> _CHENAW {
-                _CHENAW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-3 characteristics register (OTG_FS_HCCHAR3)"]
-    pub struct FS_HCCHAR3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-3 characteristics register (OTG_FS_HCCHAR3)"]
-    pub mod fs_hcchar3 {
-        #[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::FS_HCCHAR3 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDIRR {
-            bits: bool,
-        }
-        impl EPDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSDEVR {
-            bits: bool,
-        }
-        impl LSDEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ODDFRMR {
-            bits: bool,
-        }
-        impl ODDFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHDISR {
-            bits: bool,
-        }
-        impl CHDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENAR {
-            bits: bool,
-        }
-        impl CHENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSDEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSDEVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENAW<'a> {
-            #[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 = "Bits 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&self) -> EPDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDIRR { bits }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&self) -> LSDEVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSDEVR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&self) -> ODDFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDFRMR { bits }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&self) -> CHDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHDISR { bits }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&self) -> CHENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENAR { bits }
-            }
-        }
-        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 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&mut self) -> _EPNUMW {
-                _EPNUMW { w: self }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&mut self) -> _EPDIRW {
-                _EPDIRW { w: self }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&mut self) -> _LSDEVW {
-                _LSDEVW { w: self }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&mut self) -> _ODDFRMW {
-                _ODDFRMW { w: self }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&mut self) -> _CHDISW {
-                _CHDISW { w: self }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&mut self) -> _CHENAW {
-                _CHENAW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-4 characteristics register (OTG_FS_HCCHAR4)"]
-    pub struct FS_HCCHAR4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-4 characteristics register (OTG_FS_HCCHAR4)"]
-    pub mod fs_hcchar4 {
-        #[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::FS_HCCHAR4 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDIRR {
-            bits: bool,
-        }
-        impl EPDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSDEVR {
-            bits: bool,
-        }
-        impl LSDEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ODDFRMR {
-            bits: bool,
-        }
-        impl ODDFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHDISR {
-            bits: bool,
-        }
-        impl CHDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENAR {
-            bits: bool,
-        }
-        impl CHENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSDEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSDEVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENAW<'a> {
-            #[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 = "Bits 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&self) -> EPDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDIRR { bits }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&self) -> LSDEVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSDEVR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&self) -> ODDFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDFRMR { bits }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&self) -> CHDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHDISR { bits }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&self) -> CHENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENAR { bits }
-            }
-        }
-        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 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&mut self) -> _EPNUMW {
-                _EPNUMW { w: self }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&mut self) -> _EPDIRW {
-                _EPDIRW { w: self }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&mut self) -> _LSDEVW {
-                _LSDEVW { w: self }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&mut self) -> _ODDFRMW {
-                _ODDFRMW { w: self }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&mut self) -> _CHDISW {
-                _CHDISW { w: self }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&mut self) -> _CHENAW {
-                _CHENAW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-5 characteristics register (OTG_FS_HCCHAR5)"]
-    pub struct FS_HCCHAR5 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-5 characteristics register (OTG_FS_HCCHAR5)"]
-    pub mod fs_hcchar5 {
-        #[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::FS_HCCHAR5 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDIRR {
-            bits: bool,
-        }
-        impl EPDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSDEVR {
-            bits: bool,
-        }
-        impl LSDEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ODDFRMR {
-            bits: bool,
-        }
-        impl ODDFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHDISR {
-            bits: bool,
-        }
-        impl CHDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENAR {
-            bits: bool,
-        }
-        impl CHENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSDEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSDEVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENAW<'a> {
-            #[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 = "Bits 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&self) -> EPDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDIRR { bits }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&self) -> LSDEVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSDEVR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&self) -> ODDFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDFRMR { bits }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&self) -> CHDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHDISR { bits }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&self) -> CHENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENAR { bits }
-            }
-        }
-        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 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&mut self) -> _EPNUMW {
-                _EPNUMW { w: self }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&mut self) -> _EPDIRW {
-                _EPDIRW { w: self }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&mut self) -> _LSDEVW {
-                _LSDEVW { w: self }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&mut self) -> _ODDFRMW {
-                _ODDFRMW { w: self }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&mut self) -> _CHDISW {
-                _CHDISW { w: self }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&mut self) -> _CHENAW {
-                _CHENAW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-6 characteristics register (OTG_FS_HCCHAR6)"]
-    pub struct FS_HCCHAR6 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-6 characteristics register (OTG_FS_HCCHAR6)"]
-    pub mod fs_hcchar6 {
-        #[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::FS_HCCHAR6 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDIRR {
-            bits: bool,
-        }
-        impl EPDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSDEVR {
-            bits: bool,
-        }
-        impl LSDEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ODDFRMR {
-            bits: bool,
-        }
-        impl ODDFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHDISR {
-            bits: bool,
-        }
-        impl CHDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENAR {
-            bits: bool,
-        }
-        impl CHENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSDEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSDEVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENAW<'a> {
-            #[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 = "Bits 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&self) -> EPDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDIRR { bits }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&self) -> LSDEVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSDEVR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&self) -> ODDFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDFRMR { bits }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&self) -> CHDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHDISR { bits }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&self) -> CHENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENAR { bits }
-            }
-        }
-        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 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&mut self) -> _EPNUMW {
-                _EPNUMW { w: self }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&mut self) -> _EPDIRW {
-                _EPDIRW { w: self }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&mut self) -> _LSDEVW {
-                _LSDEVW { w: self }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&mut self) -> _ODDFRMW {
-                _ODDFRMW { w: self }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&mut self) -> _CHDISW {
-                _CHDISW { w: self }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&mut self) -> _CHENAW {
-                _CHENAW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-7 characteristics register (OTG_FS_HCCHAR7)"]
-    pub struct FS_HCCHAR7 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-7 characteristics register (OTG_FS_HCCHAR7)"]
-    pub mod fs_hcchar7 {
-        #[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::FS_HCCHAR7 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPNUMR {
-            bits: u8,
-        }
-        impl EPNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDIRR {
-            bits: bool,
-        }
-        impl EPDIRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSDEVR {
-            bits: bool,
-        }
-        impl LSDEVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ODDFRMR {
-            bits: bool,
-        }
-        impl ODDFRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHDISR {
-            bits: bool,
-        }
-        impl CHDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHENAR {
-            bits: bool,
-        }
-        impl CHENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 11;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDIRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDIRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSDEVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSDEVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHENAW<'a> {
-            #[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 = "Bits 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&self) -> EPNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPNUMR { bits }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&self) -> EPDIRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDIRR { bits }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&self) -> LSDEVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSDEVR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&self) -> ODDFRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ODDFRMR { bits }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&self) -> CHDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHDISR { bits }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&self) -> CHENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHENAR { bits }
-            }
-        }
-        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 0:10 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bits 11:14 - Endpoint number"]
-            #[inline]
-            pub fn epnum(&mut self) -> _EPNUMW {
-                _EPNUMW { w: self }
-            }
-            #[doc = "Bit 15 - Endpoint direction"]
-            #[inline]
-            pub fn epdir(&mut self) -> _EPDIRW {
-                _EPDIRW { w: self }
-            }
-            #[doc = "Bit 17 - Low-speed device"]
-            #[inline]
-            pub fn lsdev(&mut self) -> _LSDEVW {
-                _LSDEVW { w: self }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bits 20:21 - Multicount"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 22:28 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bit 29 - Odd frame"]
-            #[inline]
-            pub fn oddfrm(&mut self) -> _ODDFRMW {
-                _ODDFRMW { w: self }
-            }
-            #[doc = "Bit 30 - Channel disable"]
-            #[inline]
-            pub fn chdis(&mut self) -> _CHDISW {
-                _CHDISW { w: self }
-            }
-            #[doc = "Bit 31 - Channel enable"]
-            #[inline]
-            pub fn chena(&mut self) -> _CHENAW {
-                _CHENAW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-0 interrupt register (OTG_FS_HCINT0)"]
-    pub struct FS_HCINT0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-0 interrupt register (OTG_FS_HCINT0)"]
-    pub mod fs_hcint0 {
-        #[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::FS_HCINT0 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHR {
-            bits: bool,
-        }
-        impl CHHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKR {
-            bits: bool,
-        }
-        impl NAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRR {
-            bits: bool,
-        }
-        impl TXERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRR {
-            bits: bool,
-        }
-        impl BBERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORR {
-            bits: bool,
-        }
-        impl FRMORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRR {
-            bits: bool,
-        }
-        impl DTERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&self) -> CHHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&self) -> NAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&self) -> TXERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRR { bits }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&self) -> BBERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&self) -> FRMORR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&self) -> DTERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRR { bits }
-            }
-        }
-        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 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&mut self) -> _CHHW {
-                _CHHW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&mut self) -> _NAKW {
-                _NAKW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&mut self) -> _TXERRW {
-                _TXERRW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&mut self) -> _BBERRW {
-                _BBERRW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&mut self) -> _FRMORW {
-                _FRMORW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&mut self) -> _DTERRW {
-                _DTERRW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-1 interrupt register (OTG_FS_HCINT1)"]
-    pub struct FS_HCINT1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-1 interrupt register (OTG_FS_HCINT1)"]
-    pub mod fs_hcint1 {
-        #[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::FS_HCINT1 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHR {
-            bits: bool,
-        }
-        impl CHHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKR {
-            bits: bool,
-        }
-        impl NAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRR {
-            bits: bool,
-        }
-        impl TXERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRR {
-            bits: bool,
-        }
-        impl BBERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORR {
-            bits: bool,
-        }
-        impl FRMORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRR {
-            bits: bool,
-        }
-        impl DTERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&self) -> CHHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&self) -> NAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&self) -> TXERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRR { bits }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&self) -> BBERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&self) -> FRMORR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&self) -> DTERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRR { bits }
-            }
-        }
-        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 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&mut self) -> _CHHW {
-                _CHHW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&mut self) -> _NAKW {
-                _NAKW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&mut self) -> _TXERRW {
-                _TXERRW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&mut self) -> _BBERRW {
-                _BBERRW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&mut self) -> _FRMORW {
-                _FRMORW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&mut self) -> _DTERRW {
-                _DTERRW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-2 interrupt register (OTG_FS_HCINT2)"]
-    pub struct FS_HCINT2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-2 interrupt register (OTG_FS_HCINT2)"]
-    pub mod fs_hcint2 {
-        #[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::FS_HCINT2 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHR {
-            bits: bool,
-        }
-        impl CHHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKR {
-            bits: bool,
-        }
-        impl NAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRR {
-            bits: bool,
-        }
-        impl TXERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRR {
-            bits: bool,
-        }
-        impl BBERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORR {
-            bits: bool,
-        }
-        impl FRMORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRR {
-            bits: bool,
-        }
-        impl DTERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&self) -> CHHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&self) -> NAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&self) -> TXERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRR { bits }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&self) -> BBERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&self) -> FRMORR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&self) -> DTERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRR { bits }
-            }
-        }
-        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 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&mut self) -> _CHHW {
-                _CHHW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&mut self) -> _NAKW {
-                _NAKW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&mut self) -> _TXERRW {
-                _TXERRW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&mut self) -> _BBERRW {
-                _BBERRW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&mut self) -> _FRMORW {
-                _FRMORW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&mut self) -> _DTERRW {
-                _DTERRW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-3 interrupt register (OTG_FS_HCINT3)"]
-    pub struct FS_HCINT3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-3 interrupt register (OTG_FS_HCINT3)"]
-    pub mod fs_hcint3 {
-        #[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::FS_HCINT3 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHR {
-            bits: bool,
-        }
-        impl CHHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKR {
-            bits: bool,
-        }
-        impl NAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRR {
-            bits: bool,
-        }
-        impl TXERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRR {
-            bits: bool,
-        }
-        impl BBERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORR {
-            bits: bool,
-        }
-        impl FRMORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRR {
-            bits: bool,
-        }
-        impl DTERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&self) -> CHHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&self) -> NAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&self) -> TXERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRR { bits }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&self) -> BBERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&self) -> FRMORR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&self) -> DTERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRR { bits }
-            }
-        }
-        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 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&mut self) -> _CHHW {
-                _CHHW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&mut self) -> _NAKW {
-                _NAKW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&mut self) -> _TXERRW {
-                _TXERRW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&mut self) -> _BBERRW {
-                _BBERRW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&mut self) -> _FRMORW {
-                _FRMORW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&mut self) -> _DTERRW {
-                _DTERRW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-4 interrupt register (OTG_FS_HCINT4)"]
-    pub struct FS_HCINT4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-4 interrupt register (OTG_FS_HCINT4)"]
-    pub mod fs_hcint4 {
-        #[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::FS_HCINT4 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHR {
-            bits: bool,
-        }
-        impl CHHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKR {
-            bits: bool,
-        }
-        impl NAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRR {
-            bits: bool,
-        }
-        impl TXERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRR {
-            bits: bool,
-        }
-        impl BBERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORR {
-            bits: bool,
-        }
-        impl FRMORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRR {
-            bits: bool,
-        }
-        impl DTERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&self) -> CHHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&self) -> NAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&self) -> TXERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRR { bits }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&self) -> BBERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&self) -> FRMORR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&self) -> DTERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRR { bits }
-            }
-        }
-        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 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&mut self) -> _CHHW {
-                _CHHW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&mut self) -> _NAKW {
-                _NAKW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&mut self) -> _TXERRW {
-                _TXERRW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&mut self) -> _BBERRW {
-                _BBERRW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&mut self) -> _FRMORW {
-                _FRMORW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&mut self) -> _DTERRW {
-                _DTERRW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-5 interrupt register (OTG_FS_HCINT5)"]
-    pub struct FS_HCINT5 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-5 interrupt register (OTG_FS_HCINT5)"]
-    pub mod fs_hcint5 {
-        #[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::FS_HCINT5 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHR {
-            bits: bool,
-        }
-        impl CHHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKR {
-            bits: bool,
-        }
-        impl NAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRR {
-            bits: bool,
-        }
-        impl TXERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRR {
-            bits: bool,
-        }
-        impl BBERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORR {
-            bits: bool,
-        }
-        impl FRMORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRR {
-            bits: bool,
-        }
-        impl DTERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&self) -> CHHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&self) -> NAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&self) -> TXERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRR { bits }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&self) -> BBERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&self) -> FRMORR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&self) -> DTERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRR { bits }
-            }
-        }
-        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 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&mut self) -> _CHHW {
-                _CHHW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&mut self) -> _NAKW {
-                _NAKW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&mut self) -> _TXERRW {
-                _TXERRW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&mut self) -> _BBERRW {
-                _BBERRW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&mut self) -> _FRMORW {
-                _FRMORW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&mut self) -> _DTERRW {
-                _DTERRW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-6 interrupt register (OTG_FS_HCINT6)"]
-    pub struct FS_HCINT6 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-6 interrupt register (OTG_FS_HCINT6)"]
-    pub mod fs_hcint6 {
-        #[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::FS_HCINT6 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHR {
-            bits: bool,
-        }
-        impl CHHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKR {
-            bits: bool,
-        }
-        impl NAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRR {
-            bits: bool,
-        }
-        impl TXERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRR {
-            bits: bool,
-        }
-        impl BBERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORR {
-            bits: bool,
-        }
-        impl FRMORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRR {
-            bits: bool,
-        }
-        impl DTERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&self) -> CHHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&self) -> NAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&self) -> TXERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRR { bits }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&self) -> BBERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&self) -> FRMORR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&self) -> DTERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRR { bits }
-            }
-        }
-        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 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&mut self) -> _CHHW {
-                _CHHW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&mut self) -> _NAKW {
-                _NAKW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&mut self) -> _TXERRW {
-                _TXERRW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&mut self) -> _BBERRW {
-                _BBERRW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&mut self) -> _FRMORW {
-                _FRMORW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&mut self) -> _DTERRW {
-                _DTERRW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-7 interrupt register (OTG_FS_HCINT7)"]
-    pub struct FS_HCINT7 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-7 interrupt register (OTG_FS_HCINT7)"]
-    pub mod fs_hcint7 {
-        #[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::FS_HCINT7 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHR {
-            bits: bool,
-        }
-        impl CHHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKR {
-            bits: bool,
-        }
-        impl NAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKR {
-            bits: bool,
-        }
-        impl ACKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRR {
-            bits: bool,
-        }
-        impl TXERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRR {
-            bits: bool,
-        }
-        impl BBERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORR {
-            bits: bool,
-        }
-        impl FRMORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRR {
-            bits: bool,
-        }
-        impl DTERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&self) -> CHHR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&self) -> NAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&self) -> ACKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&self) -> TXERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRR { bits }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&self) -> BBERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&self) -> FRMORR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&self) -> DTERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRR { bits }
-            }
-        }
-        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 - Transfer completed"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted"]
-            #[inline]
-            pub fn chh(&mut self) -> _CHHW {
-                _CHHW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt"]
-            #[inline]
-            pub fn nak(&mut self) -> _NAKW {
-                _NAKW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt"]
-            #[inline]
-            pub fn ack(&mut self) -> _ACKW {
-                _ACKW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error"]
-            #[inline]
-            pub fn txerr(&mut self) -> _TXERRW {
-                _TXERRW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error"]
-            #[inline]
-            pub fn bberr(&mut self) -> _BBERRW {
-                _BBERRW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun"]
-            #[inline]
-            pub fn frmor(&mut self) -> _FRMORW {
-                _FRMORW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error"]
-            #[inline]
-            pub fn dterr(&mut self) -> _DTERRW {
-                _DTERRW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-0 mask register (OTG_FS_HCINTMSK0)"]
-    pub struct FS_HCINTMSK0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-0 mask register (OTG_FS_HCINTMSK0)"]
-    pub mod fs_hcintmsk0 {
-        #[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::FS_HCINTMSK0 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHMR {
-            bits: bool,
-        }
-        impl CHHMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLMR {
-            bits: bool,
-        }
-        impl STALLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKMR {
-            bits: bool,
-        }
-        impl NAKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKMR {
-            bits: bool,
-        }
-        impl ACKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NYETR {
-            bits: bool,
-        }
-        impl NYETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRMR {
-            bits: bool,
-        }
-        impl TXERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRMR {
-            bits: bool,
-        }
-        impl BBERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORMR {
-            bits: bool,
-        }
-        impl FRMORMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRMR {
-            bits: bool,
-        }
-        impl DTERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NYETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NYETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&self) -> CHHMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHMR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&self) -> STALLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLMR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&self) -> NAKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKMR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&self) -> ACKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKMR { bits }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&self) -> NYETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NYETR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&self) -> TXERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRMR { bits }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&self) -> BBERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRMR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&self) -> FRMORMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORMR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&self) -> DTERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRMR { bits }
-            }
-        }
-        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 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&mut self) -> _CHHMW {
-                _CHHMW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&mut self) -> _STALLMW {
-                _STALLMW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&mut self) -> _NAKMW {
-                _NAKMW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&mut self) -> _ACKMW {
-                _ACKMW { w: self }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&mut self) -> _NYETW {
-                _NYETW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&mut self) -> _TXERRMW {
-                _TXERRMW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&mut self) -> _BBERRMW {
-                _BBERRMW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&mut self) -> _FRMORMW {
-                _FRMORMW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&mut self) -> _DTERRMW {
-                _DTERRMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-1 mask register (OTG_FS_HCINTMSK1)"]
-    pub struct FS_HCINTMSK1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-1 mask register (OTG_FS_HCINTMSK1)"]
-    pub mod fs_hcintmsk1 {
-        #[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::FS_HCINTMSK1 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHMR {
-            bits: bool,
-        }
-        impl CHHMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLMR {
-            bits: bool,
-        }
-        impl STALLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKMR {
-            bits: bool,
-        }
-        impl NAKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKMR {
-            bits: bool,
-        }
-        impl ACKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NYETR {
-            bits: bool,
-        }
-        impl NYETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRMR {
-            bits: bool,
-        }
-        impl TXERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRMR {
-            bits: bool,
-        }
-        impl BBERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORMR {
-            bits: bool,
-        }
-        impl FRMORMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRMR {
-            bits: bool,
-        }
-        impl DTERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NYETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NYETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&self) -> CHHMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHMR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&self) -> STALLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLMR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&self) -> NAKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKMR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&self) -> ACKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKMR { bits }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&self) -> NYETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NYETR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&self) -> TXERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRMR { bits }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&self) -> BBERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRMR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&self) -> FRMORMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORMR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&self) -> DTERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRMR { bits }
-            }
-        }
-        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 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&mut self) -> _CHHMW {
-                _CHHMW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&mut self) -> _STALLMW {
-                _STALLMW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&mut self) -> _NAKMW {
-                _NAKMW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&mut self) -> _ACKMW {
-                _ACKMW { w: self }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&mut self) -> _NYETW {
-                _NYETW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&mut self) -> _TXERRMW {
-                _TXERRMW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&mut self) -> _BBERRMW {
-                _BBERRMW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&mut self) -> _FRMORMW {
-                _FRMORMW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&mut self) -> _DTERRMW {
-                _DTERRMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-2 mask register (OTG_FS_HCINTMSK2)"]
-    pub struct FS_HCINTMSK2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-2 mask register (OTG_FS_HCINTMSK2)"]
-    pub mod fs_hcintmsk2 {
-        #[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::FS_HCINTMSK2 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHMR {
-            bits: bool,
-        }
-        impl CHHMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLMR {
-            bits: bool,
-        }
-        impl STALLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKMR {
-            bits: bool,
-        }
-        impl NAKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKMR {
-            bits: bool,
-        }
-        impl ACKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NYETR {
-            bits: bool,
-        }
-        impl NYETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRMR {
-            bits: bool,
-        }
-        impl TXERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRMR {
-            bits: bool,
-        }
-        impl BBERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORMR {
-            bits: bool,
-        }
-        impl FRMORMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRMR {
-            bits: bool,
-        }
-        impl DTERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NYETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NYETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&self) -> CHHMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHMR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&self) -> STALLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLMR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&self) -> NAKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKMR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&self) -> ACKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKMR { bits }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&self) -> NYETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NYETR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&self) -> TXERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRMR { bits }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&self) -> BBERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRMR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&self) -> FRMORMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORMR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&self) -> DTERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRMR { bits }
-            }
-        }
-        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 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&mut self) -> _CHHMW {
-                _CHHMW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&mut self) -> _STALLMW {
-                _STALLMW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&mut self) -> _NAKMW {
-                _NAKMW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&mut self) -> _ACKMW {
-                _ACKMW { w: self }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&mut self) -> _NYETW {
-                _NYETW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&mut self) -> _TXERRMW {
-                _TXERRMW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&mut self) -> _BBERRMW {
-                _BBERRMW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&mut self) -> _FRMORMW {
-                _FRMORMW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&mut self) -> _DTERRMW {
-                _DTERRMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-3 mask register (OTG_FS_HCINTMSK3)"]
-    pub struct FS_HCINTMSK3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-3 mask register (OTG_FS_HCINTMSK3)"]
-    pub mod fs_hcintmsk3 {
-        #[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::FS_HCINTMSK3 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHMR {
-            bits: bool,
-        }
-        impl CHHMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLMR {
-            bits: bool,
-        }
-        impl STALLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKMR {
-            bits: bool,
-        }
-        impl NAKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKMR {
-            bits: bool,
-        }
-        impl ACKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NYETR {
-            bits: bool,
-        }
-        impl NYETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRMR {
-            bits: bool,
-        }
-        impl TXERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRMR {
-            bits: bool,
-        }
-        impl BBERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORMR {
-            bits: bool,
-        }
-        impl FRMORMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRMR {
-            bits: bool,
-        }
-        impl DTERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NYETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NYETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&self) -> CHHMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHMR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&self) -> STALLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLMR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&self) -> NAKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKMR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&self) -> ACKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKMR { bits }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&self) -> NYETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NYETR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&self) -> TXERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRMR { bits }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&self) -> BBERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRMR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&self) -> FRMORMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORMR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&self) -> DTERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRMR { bits }
-            }
-        }
-        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 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&mut self) -> _CHHMW {
-                _CHHMW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&mut self) -> _STALLMW {
-                _STALLMW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&mut self) -> _NAKMW {
-                _NAKMW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&mut self) -> _ACKMW {
-                _ACKMW { w: self }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&mut self) -> _NYETW {
-                _NYETW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&mut self) -> _TXERRMW {
-                _TXERRMW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&mut self) -> _BBERRMW {
-                _BBERRMW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&mut self) -> _FRMORMW {
-                _FRMORMW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&mut self) -> _DTERRMW {
-                _DTERRMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-4 mask register (OTG_FS_HCINTMSK4)"]
-    pub struct FS_HCINTMSK4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-4 mask register (OTG_FS_HCINTMSK4)"]
-    pub mod fs_hcintmsk4 {
-        #[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::FS_HCINTMSK4 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHMR {
-            bits: bool,
-        }
-        impl CHHMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLMR {
-            bits: bool,
-        }
-        impl STALLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKMR {
-            bits: bool,
-        }
-        impl NAKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKMR {
-            bits: bool,
-        }
-        impl ACKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NYETR {
-            bits: bool,
-        }
-        impl NYETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRMR {
-            bits: bool,
-        }
-        impl TXERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRMR {
-            bits: bool,
-        }
-        impl BBERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORMR {
-            bits: bool,
-        }
-        impl FRMORMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRMR {
-            bits: bool,
-        }
-        impl DTERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NYETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NYETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&self) -> CHHMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHMR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&self) -> STALLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLMR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&self) -> NAKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKMR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&self) -> ACKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKMR { bits }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&self) -> NYETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NYETR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&self) -> TXERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRMR { bits }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&self) -> BBERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRMR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&self) -> FRMORMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORMR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&self) -> DTERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRMR { bits }
-            }
-        }
-        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 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&mut self) -> _CHHMW {
-                _CHHMW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&mut self) -> _STALLMW {
-                _STALLMW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&mut self) -> _NAKMW {
-                _NAKMW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&mut self) -> _ACKMW {
-                _ACKMW { w: self }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&mut self) -> _NYETW {
-                _NYETW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&mut self) -> _TXERRMW {
-                _TXERRMW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&mut self) -> _BBERRMW {
-                _BBERRMW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&mut self) -> _FRMORMW {
-                _FRMORMW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&mut self) -> _DTERRMW {
-                _DTERRMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-5 mask register (OTG_FS_HCINTMSK5)"]
-    pub struct FS_HCINTMSK5 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-5 mask register (OTG_FS_HCINTMSK5)"]
-    pub mod fs_hcintmsk5 {
-        #[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::FS_HCINTMSK5 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHMR {
-            bits: bool,
-        }
-        impl CHHMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLMR {
-            bits: bool,
-        }
-        impl STALLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKMR {
-            bits: bool,
-        }
-        impl NAKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKMR {
-            bits: bool,
-        }
-        impl ACKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NYETR {
-            bits: bool,
-        }
-        impl NYETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRMR {
-            bits: bool,
-        }
-        impl TXERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRMR {
-            bits: bool,
-        }
-        impl BBERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORMR {
-            bits: bool,
-        }
-        impl FRMORMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRMR {
-            bits: bool,
-        }
-        impl DTERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NYETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NYETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&self) -> CHHMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHMR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&self) -> STALLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLMR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&self) -> NAKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKMR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&self) -> ACKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKMR { bits }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&self) -> NYETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NYETR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&self) -> TXERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRMR { bits }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&self) -> BBERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRMR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&self) -> FRMORMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORMR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&self) -> DTERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRMR { bits }
-            }
-        }
-        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 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&mut self) -> _CHHMW {
-                _CHHMW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&mut self) -> _STALLMW {
-                _STALLMW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&mut self) -> _NAKMW {
-                _NAKMW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&mut self) -> _ACKMW {
-                _ACKMW { w: self }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&mut self) -> _NYETW {
-                _NYETW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&mut self) -> _TXERRMW {
-                _TXERRMW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&mut self) -> _BBERRMW {
-                _BBERRMW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&mut self) -> _FRMORMW {
-                _FRMORMW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&mut self) -> _DTERRMW {
-                _DTERRMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-6 mask register (OTG_FS_HCINTMSK6)"]
-    pub struct FS_HCINTMSK6 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-6 mask register (OTG_FS_HCINTMSK6)"]
-    pub mod fs_hcintmsk6 {
-        #[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::FS_HCINTMSK6 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHMR {
-            bits: bool,
-        }
-        impl CHHMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLMR {
-            bits: bool,
-        }
-        impl STALLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKMR {
-            bits: bool,
-        }
-        impl NAKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKMR {
-            bits: bool,
-        }
-        impl ACKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NYETR {
-            bits: bool,
-        }
-        impl NYETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRMR {
-            bits: bool,
-        }
-        impl TXERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRMR {
-            bits: bool,
-        }
-        impl BBERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORMR {
-            bits: bool,
-        }
-        impl FRMORMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRMR {
-            bits: bool,
-        }
-        impl DTERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NYETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NYETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&self) -> CHHMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHMR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&self) -> STALLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLMR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&self) -> NAKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKMR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&self) -> ACKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKMR { bits }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&self) -> NYETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NYETR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&self) -> TXERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRMR { bits }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&self) -> BBERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRMR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&self) -> FRMORMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORMR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&self) -> DTERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRMR { bits }
-            }
-        }
-        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 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&mut self) -> _CHHMW {
-                _CHHMW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&mut self) -> _STALLMW {
-                _STALLMW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&mut self) -> _NAKMW {
-                _NAKMW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&mut self) -> _ACKMW {
-                _ACKMW { w: self }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&mut self) -> _NYETW {
-                _NYETW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&mut self) -> _TXERRMW {
-                _TXERRMW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&mut self) -> _BBERRMW {
-                _BBERRMW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&mut self) -> _FRMORMW {
-                _FRMORMW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&mut self) -> _DTERRMW {
-                _DTERRMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-7 mask register (OTG_FS_HCINTMSK7)"]
-    pub struct FS_HCINTMSK7 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-7 mask register (OTG_FS_HCINTMSK7)"]
-    pub mod fs_hcintmsk7 {
-        #[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::FS_HCINTMSK7 {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHHMR {
-            bits: bool,
-        }
-        impl CHHMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLMR {
-            bits: bool,
-        }
-        impl STALLMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKMR {
-            bits: bool,
-        }
-        impl NAKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ACKMR {
-            bits: bool,
-        }
-        impl ACKMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NYETR {
-            bits: bool,
-        }
-        impl NYETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXERRMR {
-            bits: bool,
-        }
-        impl TXERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BBERRMR {
-            bits: bool,
-        }
-        impl BBERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FRMORMR {
-            bits: bool,
-        }
-        impl FRMORMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DTERRMR {
-            bits: bool,
-        }
-        impl DTERRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHHMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHHMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NAKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NAKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ACKMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ACKMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _NYETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NYETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BBERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BBERRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FRMORMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRMORMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DTERRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DTERRMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&self) -> CHHMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CHHMR { bits }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&self) -> STALLMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLMR { bits }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&self) -> NAKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKMR { bits }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&self) -> ACKMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ACKMR { bits }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&self) -> NYETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NYETR { bits }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&self) -> TXERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXERRMR { bits }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&self) -> BBERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BBERRMR { bits }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&self) -> FRMORMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FRMORMR { bits }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&self) -> DTERRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DTERRMR { bits }
-            }
-        }
-        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 - Transfer completed mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Channel halted mask"]
-            #[inline]
-            pub fn chhm(&mut self) -> _CHHMW {
-                _CHHMW { w: self }
-            }
-            #[doc = "Bit 3 - STALL response received interrupt mask"]
-            #[inline]
-            pub fn stallm(&mut self) -> _STALLMW {
-                _STALLMW { w: self }
-            }
-            #[doc = "Bit 4 - NAK response received interrupt mask"]
-            #[inline]
-            pub fn nakm(&mut self) -> _NAKMW {
-                _NAKMW { w: self }
-            }
-            #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"]
-            #[inline]
-            pub fn ackm(&mut self) -> _ACKMW {
-                _ACKMW { w: self }
-            }
-            #[doc = "Bit 6 - response received interrupt mask"]
-            #[inline]
-            pub fn nyet(&mut self) -> _NYETW {
-                _NYETW { w: self }
-            }
-            #[doc = "Bit 7 - Transaction error mask"]
-            #[inline]
-            pub fn txerrm(&mut self) -> _TXERRMW {
-                _TXERRMW { w: self }
-            }
-            #[doc = "Bit 8 - Babble error mask"]
-            #[inline]
-            pub fn bberrm(&mut self) -> _BBERRMW {
-                _BBERRMW { w: self }
-            }
-            #[doc = "Bit 9 - Frame overrun mask"]
-            #[inline]
-            pub fn frmorm(&mut self) -> _FRMORMW {
-                _FRMORMW { w: self }
-            }
-            #[doc = "Bit 10 - Data toggle error mask"]
-            #[inline]
-            pub fn dterrm(&mut self) -> _DTERRMW {
-                _DTERRMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-0 transfer size register"]
-    pub struct FS_HCTSIZ0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-0 transfer size register"]
-    pub mod fs_hctsiz0 {
-        #[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::FS_HCTSIZ0 {
-            #[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 = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DPIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DPIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-        }
-        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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&mut self) -> _DPIDW {
-                _DPIDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-1 transfer size register"]
-    pub struct FS_HCTSIZ1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-1 transfer size register"]
-    pub mod fs_hctsiz1 {
-        #[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::FS_HCTSIZ1 {
-            #[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 = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DPIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DPIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-        }
-        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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&mut self) -> _DPIDW {
-                _DPIDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-2 transfer size register"]
-    pub struct FS_HCTSIZ2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-2 transfer size register"]
-    pub mod fs_hctsiz2 {
-        #[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::FS_HCTSIZ2 {
-            #[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 = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DPIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DPIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-        }
-        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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&mut self) -> _DPIDW {
-                _DPIDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-3 transfer size register"]
-    pub struct FS_HCTSIZ3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-3 transfer size register"]
-    pub mod fs_hctsiz3 {
-        #[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::FS_HCTSIZ3 {
-            #[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 = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DPIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DPIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-        }
-        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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&mut self) -> _DPIDW {
-                _DPIDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-x transfer size register"]
-    pub struct FS_HCTSIZ4 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-x transfer size register"]
-    pub mod fs_hctsiz4 {
-        #[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::FS_HCTSIZ4 {
-            #[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 = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DPIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DPIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-        }
-        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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&mut self) -> _DPIDW {
-                _DPIDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-5 transfer size register"]
-    pub struct FS_HCTSIZ5 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-5 transfer size register"]
-    pub mod fs_hctsiz5 {
-        #[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::FS_HCTSIZ5 {
-            #[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 = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DPIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DPIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-        }
-        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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&mut self) -> _DPIDW {
-                _DPIDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-6 transfer size register"]
-    pub struct FS_HCTSIZ6 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-6 transfer size register"]
-    pub mod fs_hctsiz6 {
-        #[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::FS_HCTSIZ6 {
-            #[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 = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DPIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DPIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-        }
-        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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&mut self) -> _DPIDW {
-                _DPIDW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS host channel-7 transfer size register"]
-    pub struct FS_HCTSIZ7 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS host channel-7 transfer size register"]
-    pub mod fs_hctsiz7 {
-        #[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::FS_HCTSIZ7 {
-            #[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 = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DPIDR {
-            bits: u8,
-        }
-        impl DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DPIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DPIDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&self) -> DPIDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DPIDR { bits }
-            }
-        }
-        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 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 29:30 - Data PID"]
-            #[inline]
-            pub fn dpid(&mut self) -> _DPIDW {
-                _DPIDW { w: self }
-            }
-        }
-    }
-}
-#[doc = "USB on the go full speed"]
-pub struct OTG_FS_DEVICE {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for OTG_FS_DEVICE {}
-impl OTG_FS_DEVICE {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const otg_fs_device::RegisterBlock {
-        0x5000_0800 as *const _
-    }
-}
-impl Deref for OTG_FS_DEVICE {
-    type Target = otg_fs_device::RegisterBlock;
-    fn deref(&self) -> &otg_fs_device::RegisterBlock {
-        unsafe { &*OTG_FS_DEVICE::ptr() }
-    }
-}
-#[doc = "USB on the go full speed"]
-pub mod otg_fs_device {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - OTG_FS device configuration register (OTG_FS_DCFG)"]
-        pub fs_dcfg: FS_DCFG,
-        #[doc = "0x04 - OTG_FS device control register (OTG_FS_DCTL)"]
-        pub fs_dctl: FS_DCTL,
-        #[doc = "0x08 - OTG_FS device status register (OTG_FS_DSTS)"]
-        pub fs_dsts: FS_DSTS,
-        _reserved0: [u8; 4usize],
-        #[doc = "0x10 - OTG_FS device IN endpoint common interrupt mask register (OTG_FS_DIEPMSK)"]
-        pub fs_diepmsk: FS_DIEPMSK,
-        #[doc = "0x14 - OTG_FS device OUT endpoint common interrupt mask register (OTG_FS_DOEPMSK)"]
-        pub fs_doepmsk: FS_DOEPMSK,
-        #[doc = "0x18 - OTG_FS device all endpoints interrupt register (OTG_FS_DAINT)"]
-        pub fs_daint: FS_DAINT,
-        #[doc = "0x1c - OTG_FS all endpoints interrupt mask register (OTG_FS_DAINTMSK)"]
-        pub fs_daintmsk: FS_DAINTMSK,
-        _reserved1: [u8; 8usize],
-        #[doc = "0x28 - OTG_FS device VBUS discharge time register"]
-        pub dvbusdis: DVBUSDIS,
-        #[doc = "0x2c - OTG_FS device VBUS pulsing time register"]
-        pub dvbuspulse: DVBUSPULSE,
-        _reserved2: [u8; 4usize],
-        #[doc = "0x34 - OTG_FS device IN endpoint FIFO empty interrupt mask register"]
-        pub diepempmsk: DIEPEMPMSK,
-        _reserved3: [u8; 200usize],
-        #[doc = "0x100 - OTG_FS device control IN endpoint 0 control register (OTG_FS_DIEPCTL0)"]
-        pub fs_diepctl0: FS_DIEPCTL0,
-        _reserved4: [u8; 4usize],
-        #[doc = "0x108 - device endpoint-x interrupt register"]
-        pub diepint0: DIEPINT0,
-        _reserved5: [u8; 4usize],
-        #[doc = "0x110 - device endpoint-0 transfer size register"]
-        pub dieptsiz0: DIEPTSIZ0,
-        _reserved6: [u8; 4usize],
-        #[doc = "0x118 - OTG_FS device IN endpoint transmit FIFO status register"]
-        pub dtxfsts0: DTXFSTS0,
-        _reserved7: [u8; 4usize],
-        #[doc = "0x120 - OTG device endpoint-1 control register"]
-        pub diepctl1: DIEPCTL1,
-        _reserved8: [u8; 4usize],
-        #[doc = "0x128 - device endpoint-1 interrupt register"]
-        pub diepint1: DIEPINT1,
-        _reserved9: [u8; 4usize],
-        #[doc = "0x130 - device endpoint-1 transfer size register"]
-        pub dieptsiz1: DIEPTSIZ1,
-        _reserved10: [u8; 4usize],
-        #[doc = "0x138 - OTG_FS device IN endpoint transmit FIFO status register"]
-        pub dtxfsts1: DTXFSTS1,
-        _reserved11: [u8; 4usize],
-        #[doc = "0x140 - OTG device endpoint-2 control register"]
-        pub diepctl2: DIEPCTL2,
-        _reserved12: [u8; 4usize],
-        #[doc = "0x148 - device endpoint-2 interrupt register"]
-        pub diepint2: DIEPINT2,
-        _reserved13: [u8; 4usize],
-        #[doc = "0x150 - device endpoint-2 transfer size register"]
-        pub dieptsiz2: DIEPTSIZ2,
-        _reserved14: [u8; 4usize],
-        #[doc = "0x158 - OTG_FS device IN endpoint transmit FIFO status register"]
-        pub dtxfsts2: DTXFSTS2,
-        _reserved15: [u8; 4usize],
-        #[doc = "0x160 - OTG device endpoint-3 control register"]
-        pub diepctl3: DIEPCTL3,
-        _reserved16: [u8; 4usize],
-        #[doc = "0x168 - device endpoint-3 interrupt register"]
-        pub diepint3: DIEPINT3,
-        _reserved17: [u8; 4usize],
-        #[doc = "0x170 - device endpoint-3 transfer size register"]
-        pub dieptsiz3: DIEPTSIZ3,
-        _reserved18: [u8; 4usize],
-        #[doc = "0x178 - OTG_FS device IN endpoint transmit FIFO status register"]
-        pub dtxfsts3: DTXFSTS3,
-        _reserved19: [u8; 388usize],
-        #[doc = "0x300 - device endpoint-0 control register"]
-        pub doepctl0: DOEPCTL0,
-        _reserved20: [u8; 4usize],
-        #[doc = "0x308 - device endpoint-0 interrupt register"]
-        pub doepint0: DOEPINT0,
-        _reserved21: [u8; 4usize],
-        #[doc = "0x310 - device OUT endpoint-0 transfer size register"]
-        pub doeptsiz0: DOEPTSIZ0,
-        _reserved22: [u8; 12usize],
-        #[doc = "0x320 - device endpoint-1 control register"]
-        pub doepctl1: DOEPCTL1,
-        _reserved23: [u8; 4usize],
-        #[doc = "0x328 - device endpoint-1 interrupt register"]
-        pub doepint1: DOEPINT1,
-        _reserved24: [u8; 4usize],
-        #[doc = "0x330 - device OUT endpoint-1 transfer size register"]
-        pub doeptsiz1: DOEPTSIZ1,
-        _reserved25: [u8; 12usize],
-        #[doc = "0x340 - device endpoint-2 control register"]
-        pub doepctl2: DOEPCTL2,
-        _reserved26: [u8; 4usize],
-        #[doc = "0x348 - device endpoint-2 interrupt register"]
-        pub doepint2: DOEPINT2,
-        _reserved27: [u8; 4usize],
-        #[doc = "0x350 - device OUT endpoint-2 transfer size register"]
-        pub doeptsiz2: DOEPTSIZ2,
-        _reserved28: [u8; 12usize],
-        #[doc = "0x360 - device endpoint-3 control register"]
-        pub doepctl3: DOEPCTL3,
-        _reserved29: [u8; 4usize],
-        #[doc = "0x368 - device endpoint-3 interrupt register"]
-        pub doepint3: DOEPINT3,
-        _reserved30: [u8; 4usize],
-        #[doc = "0x370 - device OUT endpoint-3 transfer size register"]
-        pub doeptsiz3: DOEPTSIZ3,
-    }
-    #[doc = "OTG_FS device configuration register (OTG_FS_DCFG)"]
-    pub struct FS_DCFG {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device configuration register (OTG_FS_DCFG)"]
-    pub mod fs_dcfg {
-        #[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::FS_DCFG {
-            #[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 = r" Value of the field"]
-        pub struct DSPDR {
-            bits: u8,
-        }
-        impl DSPDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NZLSOHSKR {
-            bits: bool,
-        }
-        impl NZLSOHSKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DADR {
-            bits: u8,
-        }
-        impl DADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PFIVLR {
-            bits: u8,
-        }
-        impl PFIVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DSPDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DSPDW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NZLSOHSKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NZLSOHSKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DADW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PFIVLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PFIVLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 11;
-                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 0:1 - Device speed"]
-            #[inline]
-            pub fn dspd(&self) -> DSPDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DSPDR { bits }
-            }
-            #[doc = "Bit 2 - Non-zero-length status OUT handshake"]
-            #[inline]
-            pub fn nzlsohsk(&self) -> NZLSOHSKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NZLSOHSKR { bits }
-            }
-            #[doc = "Bits 4:10 - Device address"]
-            #[inline]
-            pub fn dad(&self) -> DADR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DADR { bits }
-            }
-            #[doc = "Bits 11:12 - Periodic frame interval"]
-            #[inline]
-            pub fn pfivl(&self) -> PFIVLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PFIVLR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x0220_0000 }
-            }
-            #[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 0:1 - Device speed"]
-            #[inline]
-            pub fn dspd(&mut self) -> _DSPDW {
-                _DSPDW { w: self }
-            }
-            #[doc = "Bit 2 - Non-zero-length status OUT handshake"]
-            #[inline]
-            pub fn nzlsohsk(&mut self) -> _NZLSOHSKW {
-                _NZLSOHSKW { w: self }
-            }
-            #[doc = "Bits 4:10 - Device address"]
-            #[inline]
-            pub fn dad(&mut self) -> _DADW {
-                _DADW { w: self }
-            }
-            #[doc = "Bits 11:12 - Periodic frame interval"]
-            #[inline]
-            pub fn pfivl(&mut self) -> _PFIVLW {
-                _PFIVLW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device control register (OTG_FS_DCTL)"]
-    pub struct FS_DCTL {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device control register (OTG_FS_DCTL)"]
-    pub mod fs_dctl {
-        #[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::FS_DCTL {
-            #[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 = r" Value of the field"]
-        pub struct RWUSIGR {
-            bits: bool,
-        }
-        impl RWUSIGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SDISR {
-            bits: bool,
-        }
-        impl SDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GINSTSR {
-            bits: bool,
-        }
-        impl GINSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GONSTSR {
-            bits: bool,
-        }
-        impl GONSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCTLR {
-            bits: u8,
-        }
-        impl TCTLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SGINAKR {
-            bits: bool,
-        }
-        impl SGINAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CGINAKR {
-            bits: bool,
-        }
-        impl CGINAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SGONAKR {
-            bits: bool,
-        }
-        impl SGONAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CGONAKR {
-            bits: bool,
-        }
-        impl CGONAKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct POPRGDNER {
-            bits: bool,
-        }
-        impl POPRGDNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _RWUSIGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RWUSIGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCTLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCTLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 4;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SGINAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SGINAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CGINAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CGINAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SGONAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SGONAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CGONAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CGONAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _POPRGDNEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _POPRGDNEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Remote wakeup signaling"]
-            #[inline]
-            pub fn rwusig(&self) -> RWUSIGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RWUSIGR { bits }
-            }
-            #[doc = "Bit 1 - Soft disconnect"]
-            #[inline]
-            pub fn sdis(&self) -> SDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SDISR { bits }
-            }
-            #[doc = "Bit 2 - Global IN NAK status"]
-            #[inline]
-            pub fn ginsts(&self) -> GINSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GINSTSR { bits }
-            }
-            #[doc = "Bit 3 - Global OUT NAK status"]
-            #[inline]
-            pub fn gonsts(&self) -> GONSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GONSTSR { bits }
-            }
-            #[doc = "Bits 4:6 - Test control"]
-            #[inline]
-            pub fn tctl(&self) -> TCTLR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TCTLR { bits }
-            }
-            #[doc = "Bit 7 - Set global IN NAK"]
-            #[inline]
-            pub fn sginak(&self) -> SGINAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SGINAKR { bits }
-            }
-            #[doc = "Bit 8 - Clear global IN NAK"]
-            #[inline]
-            pub fn cginak(&self) -> CGINAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CGINAKR { bits }
-            }
-            #[doc = "Bit 9 - Set global OUT NAK"]
-            #[inline]
-            pub fn sgonak(&self) -> SGONAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SGONAKR { bits }
-            }
-            #[doc = "Bit 10 - Clear global OUT NAK"]
-            #[inline]
-            pub fn cgonak(&self) -> CGONAKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CGONAKR { bits }
-            }
-            #[doc = "Bit 11 - Power-on programming done"]
-            #[inline]
-            pub fn poprgdne(&self) -> POPRGDNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                POPRGDNER { bits }
-            }
-        }
-        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 - Remote wakeup signaling"]
-            #[inline]
-            pub fn rwusig(&mut self) -> _RWUSIGW {
-                _RWUSIGW { w: self }
-            }
-            #[doc = "Bit 1 - Soft disconnect"]
-            #[inline]
-            pub fn sdis(&mut self) -> _SDISW {
-                _SDISW { w: self }
-            }
-            #[doc = "Bits 4:6 - Test control"]
-            #[inline]
-            pub fn tctl(&mut self) -> _TCTLW {
-                _TCTLW { w: self }
-            }
-            #[doc = "Bit 7 - Set global IN NAK"]
-            #[inline]
-            pub fn sginak(&mut self) -> _SGINAKW {
-                _SGINAKW { w: self }
-            }
-            #[doc = "Bit 8 - Clear global IN NAK"]
-            #[inline]
-            pub fn cginak(&mut self) -> _CGINAKW {
-                _CGINAKW { w: self }
-            }
-            #[doc = "Bit 9 - Set global OUT NAK"]
-            #[inline]
-            pub fn sgonak(&mut self) -> _SGONAKW {
-                _SGONAKW { w: self }
-            }
-            #[doc = "Bit 10 - Clear global OUT NAK"]
-            #[inline]
-            pub fn cgonak(&mut self) -> _CGONAKW {
-                _CGONAKW { w: self }
-            }
-            #[doc = "Bit 11 - Power-on programming done"]
-            #[inline]
-            pub fn poprgdne(&mut self) -> _POPRGDNEW {
-                _POPRGDNEW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device status register (OTG_FS_DSTS)"]
-    pub struct FS_DSTS {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device status register (OTG_FS_DSTS)"]
-    pub mod fs_dsts {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FS_DSTS {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SUSPSTSR {
-            bits: bool,
-        }
-        impl SUSPSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENUMSPDR {
-            bits: u8,
-        }
-        impl ENUMSPDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EERRR {
-            bits: bool,
-        }
-        impl EERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FNSOFR {
-            bits: u16,
-        }
-        impl FNSOFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DEVLNSTSR {
-            bits: u8,
-        }
-        impl DEVLNSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Suspend status"]
-            #[inline]
-            pub fn suspsts(&self) -> SUSPSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SUSPSTSR { bits }
-            }
-            #[doc = "Bits 1:2 - Enumerated speed"]
-            #[inline]
-            pub fn enumspd(&self) -> ENUMSPDR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ENUMSPDR { bits }
-            }
-            #[doc = "Bit 3 - Erratic error"]
-            #[inline]
-            pub fn eerr(&self) -> EERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EERRR { bits }
-            }
-            #[doc = "Bits 8:21 - Frame number of the received SOF"]
-            #[inline]
-            pub fn fnsof(&self) -> FNSOFR {
-                let bits = {
-                    const MASK: u16 = 0x3fff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                FNSOFR { bits }
-            }
-            #[doc = "Bits 22:23 - Device line status"]
-            #[inline]
-            pub fn devlnsts(&self) -> DEVLNSTSR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DEVLNSTSR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint common interrupt mask register (OTG_FS_DIEPMSK)"]
-    pub struct FS_DIEPMSK {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint common interrupt mask register (OTG_FS_DIEPMSK)"]
-    pub mod fs_diepmsk {
-        #[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::FS_DIEPMSK {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDMR {
-            bits: bool,
-        }
-        impl EPDMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TOMR {
-            bits: bool,
-        }
-        impl TOMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ITTXFEMSKR {
-            bits: bool,
-        }
-        impl ITTXFEMSKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INEPNMMR {
-            bits: bool,
-        }
-        impl INEPNMMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INEPNEMR {
-            bits: bool,
-        }
-        impl INEPNEMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TOMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TOMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ITTXFEMSKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITTXFEMSKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _INEPNMMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPNMMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _INEPNEMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPNEMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed interrupt mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Endpoint disabled interrupt mask"]
-            #[inline]
-            pub fn epdm(&self) -> EPDMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDMR { bits }
-            }
-            #[doc = "Bit 3 - Timeout condition mask (Non-isochronous endpoints)"]
-            #[inline]
-            pub fn tom(&self) -> TOMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TOMR { bits }
-            }
-            #[doc = "Bit 4 - IN token received when TxFIFO empty mask"]
-            #[inline]
-            pub fn ittxfemsk(&self) -> ITTXFEMSKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ITTXFEMSKR { bits }
-            }
-            #[doc = "Bit 5 - IN token received with EP mismatch mask"]
-            #[inline]
-            pub fn inepnmm(&self) -> INEPNMMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INEPNMMR { bits }
-            }
-            #[doc = "Bit 6 - IN endpoint NAK effective mask"]
-            #[inline]
-            pub fn inepnem(&self) -> INEPNEMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INEPNEMR { bits }
-            }
-        }
-        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 - Transfer completed interrupt mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Endpoint disabled interrupt mask"]
-            #[inline]
-            pub fn epdm(&mut self) -> _EPDMW {
-                _EPDMW { w: self }
-            }
-            #[doc = "Bit 3 - Timeout condition mask (Non-isochronous endpoints)"]
-            #[inline]
-            pub fn tom(&mut self) -> _TOMW {
-                _TOMW { w: self }
-            }
-            #[doc = "Bit 4 - IN token received when TxFIFO empty mask"]
-            #[inline]
-            pub fn ittxfemsk(&mut self) -> _ITTXFEMSKW {
-                _ITTXFEMSKW { w: self }
-            }
-            #[doc = "Bit 5 - IN token received with EP mismatch mask"]
-            #[inline]
-            pub fn inepnmm(&mut self) -> _INEPNMMW {
-                _INEPNMMW { w: self }
-            }
-            #[doc = "Bit 6 - IN endpoint NAK effective mask"]
-            #[inline]
-            pub fn inepnem(&mut self) -> _INEPNEMW {
-                _INEPNEMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device OUT endpoint common interrupt mask register (OTG_FS_DOEPMSK)"]
-    pub struct FS_DOEPMSK {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device OUT endpoint common interrupt mask register (OTG_FS_DOEPMSK)"]
-    pub mod fs_doepmsk {
-        #[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::FS_DOEPMSK {
-            #[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 = r" Value of the field"]
-        pub struct XFRCMR {
-            bits: bool,
-        }
-        impl XFRCMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDMR {
-            bits: bool,
-        }
-        impl EPDMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STUPMR {
-            bits: bool,
-        }
-        impl STUPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OTEPDMR {
-            bits: bool,
-        }
-        impl OTEPDMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _XFRCMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STUPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STUPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OTEPDMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTEPDMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Transfer completed interrupt mask"]
-            #[inline]
-            pub fn xfrcm(&self) -> XFRCMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCMR { bits }
-            }
-            #[doc = "Bit 1 - Endpoint disabled interrupt mask"]
-            #[inline]
-            pub fn epdm(&self) -> EPDMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDMR { bits }
-            }
-            #[doc = "Bit 3 - SETUP phase done mask"]
-            #[inline]
-            pub fn stupm(&self) -> STUPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STUPMR { bits }
-            }
-            #[doc = "Bit 4 - OUT token received when endpoint disabled mask"]
-            #[inline]
-            pub fn otepdm(&self) -> OTEPDMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTEPDMR { bits }
-            }
-        }
-        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 - Transfer completed interrupt mask"]
-            #[inline]
-            pub fn xfrcm(&mut self) -> _XFRCMW {
-                _XFRCMW { w: self }
-            }
-            #[doc = "Bit 1 - Endpoint disabled interrupt mask"]
-            #[inline]
-            pub fn epdm(&mut self) -> _EPDMW {
-                _EPDMW { w: self }
-            }
-            #[doc = "Bit 3 - SETUP phase done mask"]
-            #[inline]
-            pub fn stupm(&mut self) -> _STUPMW {
-                _STUPMW { w: self }
-            }
-            #[doc = "Bit 4 - OUT token received when endpoint disabled mask"]
-            #[inline]
-            pub fn otepdm(&mut self) -> _OTEPDMW {
-                _OTEPDMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device all endpoints interrupt register (OTG_FS_DAINT)"]
-    pub struct FS_DAINT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device all endpoints interrupt register (OTG_FS_DAINT)"]
-    pub mod fs_daint {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::FS_DAINT {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IEPINTR {
-            bits: u16,
-        }
-        impl IEPINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OEPINTR {
-            bits: u16,
-        }
-        impl OEPINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - IN endpoint interrupt bits"]
-            #[inline]
-            pub fn iepint(&self) -> IEPINTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                IEPINTR { bits }
-            }
-            #[doc = "Bits 16:31 - OUT endpoint interrupt bits"]
-            #[inline]
-            pub fn oepint(&self) -> OEPINTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                OEPINTR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS all endpoints interrupt mask register (OTG_FS_DAINTMSK)"]
-    pub struct FS_DAINTMSK {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS all endpoints interrupt mask register (OTG_FS_DAINTMSK)"]
-    pub mod fs_daintmsk {
-        #[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::FS_DAINTMSK {
-            #[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 = r" Value of the field"]
-        pub struct IEPMR {
-            bits: u16,
-        }
-        impl IEPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct OEPINTR {
-            bits: u16,
-        }
-        impl OEPINTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IEPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IEPMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _OEPINTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OEPINTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                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 0:15 - IN EP interrupt mask bits"]
-            #[inline]
-            pub fn iepm(&self) -> IEPMR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                IEPMR { bits }
-            }
-            #[doc = "Bits 16:31 - OUT endpoint interrupt bits"]
-            #[inline]
-            pub fn oepint(&self) -> OEPINTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                OEPINTR { bits }
-            }
-        }
-        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 0:15 - IN EP interrupt mask bits"]
-            #[inline]
-            pub fn iepm(&mut self) -> _IEPMW {
-                _IEPMW { w: self }
-            }
-            #[doc = "Bits 16:31 - OUT endpoint interrupt bits"]
-            #[inline]
-            pub fn oepint(&mut self) -> _OEPINTW {
-                _OEPINTW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device VBUS discharge time register"]
-    pub struct DVBUSDIS {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device VBUS discharge time register"]
-    pub mod dvbusdis {
-        #[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::DVBUSDIS {
-            #[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 = r" Value of the field"]
-        pub struct VBUSDTR {
-            bits: u16,
-        }
-        impl VBUSDTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _VBUSDTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _VBUSDTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Device VBUS discharge time"]
-            #[inline]
-            pub fn vbusdt(&self) -> VBUSDTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                VBUSDTR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x17d7 }
-            }
-            #[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 0:15 - Device VBUS discharge time"]
-            #[inline]
-            pub fn vbusdt(&mut self) -> _VBUSDTW {
-                _VBUSDTW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device VBUS pulsing time register"]
-    pub struct DVBUSPULSE {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device VBUS pulsing time register"]
-    pub mod dvbuspulse {
-        #[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::DVBUSPULSE {
-            #[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 = r" Value of the field"]
-        pub struct DVBUSPR {
-            bits: u16,
-        }
-        impl DVBUSPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DVBUSPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DVBUSPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - Device VBUS pulsing time"]
-            #[inline]
-            pub fn dvbusp(&self) -> DVBUSPR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DVBUSPR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x05b8 }
-            }
-            #[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 0:11 - Device VBUS pulsing time"]
-            #[inline]
-            pub fn dvbusp(&mut self) -> _DVBUSPW {
-                _DVBUSPW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint FIFO empty interrupt mask register"]
-    pub struct DIEPEMPMSK {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint FIFO empty interrupt mask register"]
-    pub mod diepempmsk {
-        #[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::DIEPEMPMSK {
-            #[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 = r" Value of the field"]
-        pub struct INEPTXFEMR {
-            bits: u16,
-        }
-        impl INEPTXFEMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INEPTXFEMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPTXFEMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - IN EP Tx FIFO empty interrupt mask bits"]
-            #[inline]
-            pub fn ineptxfem(&self) -> INEPTXFEMR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTXFEMR { bits }
-            }
-        }
-        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 0:15 - IN EP Tx FIFO empty interrupt mask bits"]
-            #[inline]
-            pub fn ineptxfem(&mut self) -> _INEPTXFEMW {
-                _INEPTXFEMW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device control IN endpoint 0 control register (OTG_FS_DIEPCTL0)"]
-    pub struct FS_DIEPCTL0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device control IN endpoint 0 control register (OTG_FS_DIEPCTL0)"]
-    pub mod fs_diepctl0 {
-        #[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::FS_DIEPCTL0 {
-            #[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 = r" Value of the field"]
-        pub struct MPSIZR {
-            bits: u8,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct USBAEPR {
-            bits: bool,
-        }
-        impl USBAEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct NAKSTSR {
-            bits: bool,
-        }
-        impl NAKSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFNUMR {
-            bits: u8,
-        }
-        impl TXFNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct EPDISR {
-            bits: bool,
-        }
-        impl EPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPENAR {
-            bits: bool,
-        }
-        impl EPENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 0;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNAKW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:1 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MPSIZR { bits }
-            }
-            #[doc = "Bit 15 - USB active endpoint"]
-            #[inline]
-            pub fn usbaep(&self) -> USBAEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBAEPR { bits }
-            }
-            #[doc = "Bit 17 - NAK status"]
-            #[inline]
-            pub fn naksts(&self) -> NAKSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKSTSR { bits }
-            }
-            #[doc = "Bits 18:19 - Endpoint type"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bit 21 - STALL handshake"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bits 22:25 - TxFIFO number"]
-            #[inline]
-            pub fn txfnum(&self) -> TXFNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TXFNUMR { bits }
-            }
-            #[doc = "Bit 30 - Endpoint disable"]
-            #[inline]
-            pub fn epdis(&self) -> EPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISR { bits }
-            }
-            #[doc = "Bit 31 - Endpoint enable"]
-            #[inline]
-            pub fn epena(&self) -> EPENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPENAR { bits }
-            }
-        }
-        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 0:1 - Maximum packet size"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-            #[doc = "Bit 21 - STALL handshake"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bits 22:25 - TxFIFO number"]
-            #[inline]
-            pub fn txfnum(&mut self) -> _TXFNUMW {
-                _TXFNUMW { w: self }
-            }
-            #[doc = "Bit 26 - Clear NAK"]
-            #[inline]
-            pub fn cnak(&mut self) -> _CNAKW {
-                _CNAKW { w: self }
-            }
-            #[doc = "Bit 27 - Set NAK"]
-            #[inline]
-            pub fn snak(&mut self) -> _SNAKW {
-                _SNAKW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG device endpoint-1 control register"]
-    pub struct DIEPCTL1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG device endpoint-1 control register"]
-    pub mod diepctl1 {
-        #[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::DIEPCTL1 {
-            #[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 = r" Value of the field"]
-        pub struct EPENAR {
-            bits: bool,
-        }
-        impl EPENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISR {
-            bits: bool,
-        }
-        impl EPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFNUMR {
-            bits: u8,
-        }
-        impl TXFNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NAKSTSR {
-            bits: bool,
-        }
-        impl NAKSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EONUM_DPIDR {
-            bits: bool,
-        }
-        impl EONUM_DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBAEPR {
-            bits: bool,
-        }
-        impl USBAEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPENAW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SODDFRM_SD1PIDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SODDFRM_SD1PIDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SD0PID_SEVNFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SD0PID_SEVNFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _USBAEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBAEPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                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 = "Bit 31 - EPENA"]
-            #[inline]
-            pub fn epena(&self) -> EPENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPENAR { bits }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&self) -> EPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISR { bits }
-            }
-            #[doc = "Bits 22:25 - TXFNUM"]
-            #[inline]
-            pub fn txfnum(&self) -> TXFNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TXFNUMR { bits }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bit 17 - NAKSTS"]
-            #[inline]
-            pub fn naksts(&self) -> NAKSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKSTSR { bits }
-            }
-            #[doc = "Bit 16 - EONUM/DPID"]
-            #[inline]
-            pub fn eonum_dpid(&self) -> EONUM_DPIDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EONUM_DPIDR { bits }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&self) -> USBAEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBAEPR { bits }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-        }
-        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 31 - EPENA"]
-            #[inline]
-            pub fn epena(&mut self) -> _EPENAW {
-                _EPENAW { w: self }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&mut self) -> _EPDISW {
-                _EPDISW { w: self }
-            }
-            #[doc = "Bit 29 - SODDFRM/SD1PID"]
-            #[inline]
-            pub fn soddfrm_sd1pid(&mut self) -> _SODDFRM_SD1PIDW {
-                _SODDFRM_SD1PIDW { w: self }
-            }
-            #[doc = "Bit 28 - SD0PID/SEVNFRM"]
-            #[inline]
-            pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW {
-                _SD0PID_SEVNFRMW { w: self }
-            }
-            #[doc = "Bit 27 - SNAK"]
-            #[inline]
-            pub fn snak(&mut self) -> _SNAKW {
-                _SNAKW { w: self }
-            }
-            #[doc = "Bit 26 - CNAK"]
-            #[inline]
-            pub fn cnak(&mut self) -> _CNAKW {
-                _CNAKW { w: self }
-            }
-            #[doc = "Bits 22:25 - TXFNUM"]
-            #[inline]
-            pub fn txfnum(&mut self) -> _TXFNUMW {
-                _TXFNUMW { w: self }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&mut self) -> _USBAEPW {
-                _USBAEPW { w: self }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG device endpoint-2 control register"]
-    pub struct DIEPCTL2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG device endpoint-2 control register"]
-    pub mod diepctl2 {
-        #[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::DIEPCTL2 {
-            #[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 = r" Value of the field"]
-        pub struct EPENAR {
-            bits: bool,
-        }
-        impl EPENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISR {
-            bits: bool,
-        }
-        impl EPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFNUMR {
-            bits: u8,
-        }
-        impl TXFNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NAKSTSR {
-            bits: bool,
-        }
-        impl NAKSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EONUM_DPIDR {
-            bits: bool,
-        }
-        impl EONUM_DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBAEPR {
-            bits: bool,
-        }
-        impl USBAEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPENAW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SD0PID_SEVNFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SD0PID_SEVNFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _USBAEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBAEPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                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 = "Bit 31 - EPENA"]
-            #[inline]
-            pub fn epena(&self) -> EPENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPENAR { bits }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&self) -> EPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISR { bits }
-            }
-            #[doc = "Bits 22:25 - TXFNUM"]
-            #[inline]
-            pub fn txfnum(&self) -> TXFNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TXFNUMR { bits }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bit 17 - NAKSTS"]
-            #[inline]
-            pub fn naksts(&self) -> NAKSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKSTSR { bits }
-            }
-            #[doc = "Bit 16 - EONUM/DPID"]
-            #[inline]
-            pub fn eonum_dpid(&self) -> EONUM_DPIDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EONUM_DPIDR { bits }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&self) -> USBAEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBAEPR { bits }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-        }
-        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 31 - EPENA"]
-            #[inline]
-            pub fn epena(&mut self) -> _EPENAW {
-                _EPENAW { w: self }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&mut self) -> _EPDISW {
-                _EPDISW { w: self }
-            }
-            #[doc = "Bit 29 - SODDFRM"]
-            #[inline]
-            pub fn soddfrm(&mut self) -> _SODDFRMW {
-                _SODDFRMW { w: self }
-            }
-            #[doc = "Bit 28 - SD0PID/SEVNFRM"]
-            #[inline]
-            pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW {
-                _SD0PID_SEVNFRMW { w: self }
-            }
-            #[doc = "Bit 27 - SNAK"]
-            #[inline]
-            pub fn snak(&mut self) -> _SNAKW {
-                _SNAKW { w: self }
-            }
-            #[doc = "Bit 26 - CNAK"]
-            #[inline]
-            pub fn cnak(&mut self) -> _CNAKW {
-                _CNAKW { w: self }
-            }
-            #[doc = "Bits 22:25 - TXFNUM"]
-            #[inline]
-            pub fn txfnum(&mut self) -> _TXFNUMW {
-                _TXFNUMW { w: self }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&mut self) -> _USBAEPW {
-                _USBAEPW { w: self }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG device endpoint-3 control register"]
-    pub struct DIEPCTL3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG device endpoint-3 control register"]
-    pub mod diepctl3 {
-        #[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::DIEPCTL3 {
-            #[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 = r" Value of the field"]
-        pub struct EPENAR {
-            bits: bool,
-        }
-        impl EPENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISR {
-            bits: bool,
-        }
-        impl EPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TXFNUMR {
-            bits: u8,
-        }
-        impl TXFNUMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NAKSTSR {
-            bits: bool,
-        }
-        impl NAKSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EONUM_DPIDR {
-            bits: bool,
-        }
-        impl EONUM_DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBAEPR {
-            bits: bool,
-        }
-        impl USBAEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPENAW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SD0PID_SEVNFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SD0PID_SEVNFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TXFNUMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TXFNUMW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _USBAEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBAEPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                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 = "Bit 31 - EPENA"]
-            #[inline]
-            pub fn epena(&self) -> EPENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPENAR { bits }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&self) -> EPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISR { bits }
-            }
-            #[doc = "Bits 22:25 - TXFNUM"]
-            #[inline]
-            pub fn txfnum(&self) -> TXFNUMR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TXFNUMR { bits }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bit 17 - NAKSTS"]
-            #[inline]
-            pub fn naksts(&self) -> NAKSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKSTSR { bits }
-            }
-            #[doc = "Bit 16 - EONUM/DPID"]
-            #[inline]
-            pub fn eonum_dpid(&self) -> EONUM_DPIDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EONUM_DPIDR { bits }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&self) -> USBAEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBAEPR { bits }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-        }
-        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 31 - EPENA"]
-            #[inline]
-            pub fn epena(&mut self) -> _EPENAW {
-                _EPENAW { w: self }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&mut self) -> _EPDISW {
-                _EPDISW { w: self }
-            }
-            #[doc = "Bit 29 - SODDFRM"]
-            #[inline]
-            pub fn soddfrm(&mut self) -> _SODDFRMW {
-                _SODDFRMW { w: self }
-            }
-            #[doc = "Bit 28 - SD0PID/SEVNFRM"]
-            #[inline]
-            pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW {
-                _SD0PID_SEVNFRMW { w: self }
-            }
-            #[doc = "Bit 27 - SNAK"]
-            #[inline]
-            pub fn snak(&mut self) -> _SNAKW {
-                _SNAKW { w: self }
-            }
-            #[doc = "Bit 26 - CNAK"]
-            #[inline]
-            pub fn cnak(&mut self) -> _CNAKW {
-                _CNAKW { w: self }
-            }
-            #[doc = "Bits 22:25 - TXFNUM"]
-            #[inline]
-            pub fn txfnum(&mut self) -> _TXFNUMW {
-                _TXFNUMW { w: self }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&mut self) -> _USBAEPW {
-                _USBAEPW { w: self }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-0 control register"]
-    pub struct DOEPCTL0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-0 control register"]
-    pub mod doepctl0 {
-        #[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::DOEPCTL0 {
-            #[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 = r" Value of the field"]
-        pub struct EPDISR {
-            bits: bool,
-        }
-        impl EPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SNPMR {
-            bits: bool,
-        }
-        impl SNPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NAKSTSR {
-            bits: bool,
-        }
-        impl NAKSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBAEPR {
-            bits: bool,
-        }
-        impl USBAEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MPSIZR {
-            bits: u8,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPENAW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNPMW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&self) -> EPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISR { bits }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 20 - SNPM"]
-            #[inline]
-            pub fn snpm(&self) -> SNPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SNPMR { bits }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bit 17 - NAKSTS"]
-            #[inline]
-            pub fn naksts(&self) -> NAKSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKSTSR { bits }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&self) -> USBAEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBAEPR { bits }
-            }
-            #[doc = "Bits 0:1 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MPSIZR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x8000 }
-            }
-            #[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 31 - EPENA"]
-            #[inline]
-            pub fn epena(&mut self) -> _EPENAW {
-                _EPENAW { w: self }
-            }
-            #[doc = "Bit 27 - SNAK"]
-            #[inline]
-            pub fn snak(&mut self) -> _SNAKW {
-                _SNAKW { w: self }
-            }
-            #[doc = "Bit 26 - CNAK"]
-            #[inline]
-            pub fn cnak(&mut self) -> _CNAKW {
-                _CNAKW { w: self }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 20 - SNPM"]
-            #[inline]
-            pub fn snpm(&mut self) -> _SNPMW {
-                _SNPMW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-1 control register"]
-    pub struct DOEPCTL1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-1 control register"]
-    pub mod doepctl1 {
-        #[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::DOEPCTL1 {
-            #[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 = r" Value of the field"]
-        pub struct EPENAR {
-            bits: bool,
-        }
-        impl EPENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISR {
-            bits: bool,
-        }
-        impl EPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SNPMR {
-            bits: bool,
-        }
-        impl SNPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NAKSTSR {
-            bits: bool,
-        }
-        impl NAKSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EONUM_DPIDR {
-            bits: bool,
-        }
-        impl EONUM_DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBAEPR {
-            bits: bool,
-        }
-        impl USBAEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPENAW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SD0PID_SEVNFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SD0PID_SEVNFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _USBAEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBAEPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                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 = "Bit 31 - EPENA"]
-            #[inline]
-            pub fn epena(&self) -> EPENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPENAR { bits }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&self) -> EPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISR { bits }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 20 - SNPM"]
-            #[inline]
-            pub fn snpm(&self) -> SNPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SNPMR { bits }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bit 17 - NAKSTS"]
-            #[inline]
-            pub fn naksts(&self) -> NAKSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKSTSR { bits }
-            }
-            #[doc = "Bit 16 - EONUM/DPID"]
-            #[inline]
-            pub fn eonum_dpid(&self) -> EONUM_DPIDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EONUM_DPIDR { bits }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&self) -> USBAEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBAEPR { bits }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-        }
-        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 31 - EPENA"]
-            #[inline]
-            pub fn epena(&mut self) -> _EPENAW {
-                _EPENAW { w: self }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&mut self) -> _EPDISW {
-                _EPDISW { w: self }
-            }
-            #[doc = "Bit 29 - SODDFRM"]
-            #[inline]
-            pub fn soddfrm(&mut self) -> _SODDFRMW {
-                _SODDFRMW { w: self }
-            }
-            #[doc = "Bit 28 - SD0PID/SEVNFRM"]
-            #[inline]
-            pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW {
-                _SD0PID_SEVNFRMW { w: self }
-            }
-            #[doc = "Bit 27 - SNAK"]
-            #[inline]
-            pub fn snak(&mut self) -> _SNAKW {
-                _SNAKW { w: self }
-            }
-            #[doc = "Bit 26 - CNAK"]
-            #[inline]
-            pub fn cnak(&mut self) -> _CNAKW {
-                _CNAKW { w: self }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 20 - SNPM"]
-            #[inline]
-            pub fn snpm(&mut self) -> _SNPMW {
-                _SNPMW { w: self }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&mut self) -> _USBAEPW {
-                _USBAEPW { w: self }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-2 control register"]
-    pub struct DOEPCTL2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-2 control register"]
-    pub mod doepctl2 {
-        #[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::DOEPCTL2 {
-            #[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 = r" Value of the field"]
-        pub struct EPENAR {
-            bits: bool,
-        }
-        impl EPENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISR {
-            bits: bool,
-        }
-        impl EPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SNPMR {
-            bits: bool,
-        }
-        impl SNPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NAKSTSR {
-            bits: bool,
-        }
-        impl NAKSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EONUM_DPIDR {
-            bits: bool,
-        }
-        impl EONUM_DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBAEPR {
-            bits: bool,
-        }
-        impl USBAEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPENAW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SD0PID_SEVNFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SD0PID_SEVNFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _USBAEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBAEPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                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 = "Bit 31 - EPENA"]
-            #[inline]
-            pub fn epena(&self) -> EPENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPENAR { bits }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&self) -> EPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISR { bits }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 20 - SNPM"]
-            #[inline]
-            pub fn snpm(&self) -> SNPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SNPMR { bits }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bit 17 - NAKSTS"]
-            #[inline]
-            pub fn naksts(&self) -> NAKSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKSTSR { bits }
-            }
-            #[doc = "Bit 16 - EONUM/DPID"]
-            #[inline]
-            pub fn eonum_dpid(&self) -> EONUM_DPIDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EONUM_DPIDR { bits }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&self) -> USBAEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBAEPR { bits }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-        }
-        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 31 - EPENA"]
-            #[inline]
-            pub fn epena(&mut self) -> _EPENAW {
-                _EPENAW { w: self }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&mut self) -> _EPDISW {
-                _EPDISW { w: self }
-            }
-            #[doc = "Bit 29 - SODDFRM"]
-            #[inline]
-            pub fn soddfrm(&mut self) -> _SODDFRMW {
-                _SODDFRMW { w: self }
-            }
-            #[doc = "Bit 28 - SD0PID/SEVNFRM"]
-            #[inline]
-            pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW {
-                _SD0PID_SEVNFRMW { w: self }
-            }
-            #[doc = "Bit 27 - SNAK"]
-            #[inline]
-            pub fn snak(&mut self) -> _SNAKW {
-                _SNAKW { w: self }
-            }
-            #[doc = "Bit 26 - CNAK"]
-            #[inline]
-            pub fn cnak(&mut self) -> _CNAKW {
-                _CNAKW { w: self }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 20 - SNPM"]
-            #[inline]
-            pub fn snpm(&mut self) -> _SNPMW {
-                _SNPMW { w: self }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&mut self) -> _USBAEPW {
-                _USBAEPW { w: self }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-3 control register"]
-    pub struct DOEPCTL3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-3 control register"]
-    pub mod doepctl3 {
-        #[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::DOEPCTL3 {
-            #[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 = r" Value of the field"]
-        pub struct EPENAR {
-            bits: bool,
-        }
-        impl EPENAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISR {
-            bits: bool,
-        }
-        impl EPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STALLR {
-            bits: bool,
-        }
-        impl STALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SNPMR {
-            bits: bool,
-        }
-        impl SNPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPTYPR {
-            bits: u8,
-        }
-        impl EPTYPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NAKSTSR {
-            bits: bool,
-        }
-        impl NAKSTSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EONUM_DPIDR {
-            bits: bool,
-        }
-        impl EONUM_DPIDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct USBAEPR {
-            bits: bool,
-        }
-        impl USBAEPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MPSIZR {
-            bits: u16,
-        }
-        impl MPSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPENAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPENAW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _EPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SODDFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SODDFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SD0PID_SEVNFRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SD0PID_SEVNFRMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNAKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNAKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STALLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNPMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNPMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPTYPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPTYPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _USBAEPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _USBAEPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MPSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MPSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x07ff;
-                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 = "Bit 31 - EPENA"]
-            #[inline]
-            pub fn epena(&self) -> EPENAR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPENAR { bits }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&self) -> EPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISR { bits }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&self) -> STALLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STALLR { bits }
-            }
-            #[doc = "Bit 20 - SNPM"]
-            #[inline]
-            pub fn snpm(&self) -> SNPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SNPMR { bits }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&self) -> EPTYPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                EPTYPR { bits }
-            }
-            #[doc = "Bit 17 - NAKSTS"]
-            #[inline]
-            pub fn naksts(&self) -> NAKSTSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NAKSTSR { bits }
-            }
-            #[doc = "Bit 16 - EONUM/DPID"]
-            #[inline]
-            pub fn eonum_dpid(&self) -> EONUM_DPIDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EONUM_DPIDR { bits }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&self) -> USBAEPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 15;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                USBAEPR { bits }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&self) -> MPSIZR {
-                let bits = {
-                    const MASK: u16 = 0x07ff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                MPSIZR { bits }
-            }
-        }
-        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 31 - EPENA"]
-            #[inline]
-            pub fn epena(&mut self) -> _EPENAW {
-                _EPENAW { w: self }
-            }
-            #[doc = "Bit 30 - EPDIS"]
-            #[inline]
-            pub fn epdis(&mut self) -> _EPDISW {
-                _EPDISW { w: self }
-            }
-            #[doc = "Bit 29 - SODDFRM"]
-            #[inline]
-            pub fn soddfrm(&mut self) -> _SODDFRMW {
-                _SODDFRMW { w: self }
-            }
-            #[doc = "Bit 28 - SD0PID/SEVNFRM"]
-            #[inline]
-            pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW {
-                _SD0PID_SEVNFRMW { w: self }
-            }
-            #[doc = "Bit 27 - SNAK"]
-            #[inline]
-            pub fn snak(&mut self) -> _SNAKW {
-                _SNAKW { w: self }
-            }
-            #[doc = "Bit 26 - CNAK"]
-            #[inline]
-            pub fn cnak(&mut self) -> _CNAKW {
-                _CNAKW { w: self }
-            }
-            #[doc = "Bit 21 - Stall"]
-            #[inline]
-            pub fn stall(&mut self) -> _STALLW {
-                _STALLW { w: self }
-            }
-            #[doc = "Bit 20 - SNPM"]
-            #[inline]
-            pub fn snpm(&mut self) -> _SNPMW {
-                _SNPMW { w: self }
-            }
-            #[doc = "Bits 18:19 - EPTYP"]
-            #[inline]
-            pub fn eptyp(&mut self) -> _EPTYPW {
-                _EPTYPW { w: self }
-            }
-            #[doc = "Bit 15 - USBAEP"]
-            #[inline]
-            pub fn usbaep(&mut self) -> _USBAEPW {
-                _USBAEPW { w: self }
-            }
-            #[doc = "Bits 0:10 - MPSIZ"]
-            #[inline]
-            pub fn mpsiz(&mut self) -> _MPSIZW {
-                _MPSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-x interrupt register"]
-    pub struct DIEPINT0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-x interrupt register"]
-    pub mod diepint0 {
-        #[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::DIEPINT0 {
-            #[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 = r" Value of the field"]
-        pub struct TXFER {
-            bits: bool,
-        }
-        impl TXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INEPNER {
-            bits: bool,
-        }
-        impl INEPNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ITTXFER {
-            bits: bool,
-        }
-        impl ITTXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TOCR {
-            bits: bool,
-        }
-        impl TOCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISDR {
-            bits: bool,
-        }
-        impl EPDISDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _INEPNEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPNEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ITTXFEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITTXFEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TOCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TOCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDISDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - TXFE"]
-            #[inline]
-            pub fn txfe(&self) -> TXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFER { bits }
-            }
-            #[doc = "Bit 6 - INEPNE"]
-            #[inline]
-            pub fn inepne(&self) -> INEPNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INEPNER { bits }
-            }
-            #[doc = "Bit 4 - ITTXFE"]
-            #[inline]
-            pub fn ittxfe(&self) -> ITTXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ITTXFER { bits }
-            }
-            #[doc = "Bit 3 - TOC"]
-            #[inline]
-            pub fn toc(&self) -> TOCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TOCR { bits }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&self) -> EPDISDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISDR { bits }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x80 }
-            }
-            #[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 6 - INEPNE"]
-            #[inline]
-            pub fn inepne(&mut self) -> _INEPNEW {
-                _INEPNEW { w: self }
-            }
-            #[doc = "Bit 4 - ITTXFE"]
-            #[inline]
-            pub fn ittxfe(&mut self) -> _ITTXFEW {
-                _ITTXFEW { w: self }
-            }
-            #[doc = "Bit 3 - TOC"]
-            #[inline]
-            pub fn toc(&mut self) -> _TOCW {
-                _TOCW { w: self }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&mut self) -> _EPDISDW {
-                _EPDISDW { w: self }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-1 interrupt register"]
-    pub struct DIEPINT1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-1 interrupt register"]
-    pub mod diepint1 {
-        #[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::DIEPINT1 {
-            #[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 = r" Value of the field"]
-        pub struct TXFER {
-            bits: bool,
-        }
-        impl TXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INEPNER {
-            bits: bool,
-        }
-        impl INEPNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ITTXFER {
-            bits: bool,
-        }
-        impl ITTXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TOCR {
-            bits: bool,
-        }
-        impl TOCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISDR {
-            bits: bool,
-        }
-        impl EPDISDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _INEPNEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPNEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ITTXFEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITTXFEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TOCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TOCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDISDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - TXFE"]
-            #[inline]
-            pub fn txfe(&self) -> TXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFER { bits }
-            }
-            #[doc = "Bit 6 - INEPNE"]
-            #[inline]
-            pub fn inepne(&self) -> INEPNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INEPNER { bits }
-            }
-            #[doc = "Bit 4 - ITTXFE"]
-            #[inline]
-            pub fn ittxfe(&self) -> ITTXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ITTXFER { bits }
-            }
-            #[doc = "Bit 3 - TOC"]
-            #[inline]
-            pub fn toc(&self) -> TOCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TOCR { bits }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&self) -> EPDISDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISDR { bits }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x80 }
-            }
-            #[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 6 - INEPNE"]
-            #[inline]
-            pub fn inepne(&mut self) -> _INEPNEW {
-                _INEPNEW { w: self }
-            }
-            #[doc = "Bit 4 - ITTXFE"]
-            #[inline]
-            pub fn ittxfe(&mut self) -> _ITTXFEW {
-                _ITTXFEW { w: self }
-            }
-            #[doc = "Bit 3 - TOC"]
-            #[inline]
-            pub fn toc(&mut self) -> _TOCW {
-                _TOCW { w: self }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&mut self) -> _EPDISDW {
-                _EPDISDW { w: self }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-2 interrupt register"]
-    pub struct DIEPINT2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-2 interrupt register"]
-    pub mod diepint2 {
-        #[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::DIEPINT2 {
-            #[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 = r" Value of the field"]
-        pub struct TXFER {
-            bits: bool,
-        }
-        impl TXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INEPNER {
-            bits: bool,
-        }
-        impl INEPNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ITTXFER {
-            bits: bool,
-        }
-        impl ITTXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TOCR {
-            bits: bool,
-        }
-        impl TOCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISDR {
-            bits: bool,
-        }
-        impl EPDISDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _INEPNEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPNEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ITTXFEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITTXFEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TOCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TOCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDISDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - TXFE"]
-            #[inline]
-            pub fn txfe(&self) -> TXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFER { bits }
-            }
-            #[doc = "Bit 6 - INEPNE"]
-            #[inline]
-            pub fn inepne(&self) -> INEPNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INEPNER { bits }
-            }
-            #[doc = "Bit 4 - ITTXFE"]
-            #[inline]
-            pub fn ittxfe(&self) -> ITTXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ITTXFER { bits }
-            }
-            #[doc = "Bit 3 - TOC"]
-            #[inline]
-            pub fn toc(&self) -> TOCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TOCR { bits }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&self) -> EPDISDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISDR { bits }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x80 }
-            }
-            #[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 6 - INEPNE"]
-            #[inline]
-            pub fn inepne(&mut self) -> _INEPNEW {
-                _INEPNEW { w: self }
-            }
-            #[doc = "Bit 4 - ITTXFE"]
-            #[inline]
-            pub fn ittxfe(&mut self) -> _ITTXFEW {
-                _ITTXFEW { w: self }
-            }
-            #[doc = "Bit 3 - TOC"]
-            #[inline]
-            pub fn toc(&mut self) -> _TOCW {
-                _TOCW { w: self }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&mut self) -> _EPDISDW {
-                _EPDISDW { w: self }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-3 interrupt register"]
-    pub struct DIEPINT3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-3 interrupt register"]
-    pub mod diepint3 {
-        #[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::DIEPINT3 {
-            #[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 = r" Value of the field"]
-        pub struct TXFER {
-            bits: bool,
-        }
-        impl TXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct INEPNER {
-            bits: bool,
-        }
-        impl INEPNER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ITTXFER {
-            bits: bool,
-        }
-        impl ITTXFER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TOCR {
-            bits: bool,
-        }
-        impl TOCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISDR {
-            bits: bool,
-        }
-        impl EPDISDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _INEPNEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INEPNEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ITTXFEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ITTXFEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TOCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TOCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDISDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 7 - TXFE"]
-            #[inline]
-            pub fn txfe(&self) -> TXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TXFER { bits }
-            }
-            #[doc = "Bit 6 - INEPNE"]
-            #[inline]
-            pub fn inepne(&self) -> INEPNER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                INEPNER { bits }
-            }
-            #[doc = "Bit 4 - ITTXFE"]
-            #[inline]
-            pub fn ittxfe(&self) -> ITTXFER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ITTXFER { bits }
-            }
-            #[doc = "Bit 3 - TOC"]
-            #[inline]
-            pub fn toc(&self) -> TOCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TOCR { bits }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&self) -> EPDISDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISDR { bits }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x80 }
-            }
-            #[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 6 - INEPNE"]
-            #[inline]
-            pub fn inepne(&mut self) -> _INEPNEW {
-                _INEPNEW { w: self }
-            }
-            #[doc = "Bit 4 - ITTXFE"]
-            #[inline]
-            pub fn ittxfe(&mut self) -> _ITTXFEW {
-                _ITTXFEW { w: self }
-            }
-            #[doc = "Bit 3 - TOC"]
-            #[inline]
-            pub fn toc(&mut self) -> _TOCW {
-                _TOCW { w: self }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&mut self) -> _EPDISDW {
-                _EPDISDW { w: self }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-0 interrupt register"]
-    pub struct DOEPINT0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-0 interrupt register"]
-    pub mod doepint0 {
-        #[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::DOEPINT0 {
-            #[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 = r" Value of the field"]
-        pub struct B2BSTUPR {
-            bits: bool,
-        }
-        impl B2BSTUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OTEPDISR {
-            bits: bool,
-        }
-        impl OTEPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STUPR {
-            bits: bool,
-        }
-        impl STUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISDR {
-            bits: bool,
-        }
-        impl EPDISDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _B2BSTUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _B2BSTUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OTEPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTEPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDISDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - B2BSTUP"]
-            #[inline]
-            pub fn b2bstup(&self) -> B2BSTUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                B2BSTUPR { bits }
-            }
-            #[doc = "Bit 4 - OTEPDIS"]
-            #[inline]
-            pub fn otepdis(&self) -> OTEPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTEPDISR { bits }
-            }
-            #[doc = "Bit 3 - STUP"]
-            #[inline]
-            pub fn stup(&self) -> STUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STUPR { bits }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&self) -> EPDISDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISDR { bits }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x80 }
-            }
-            #[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 6 - B2BSTUP"]
-            #[inline]
-            pub fn b2bstup(&mut self) -> _B2BSTUPW {
-                _B2BSTUPW { w: self }
-            }
-            #[doc = "Bit 4 - OTEPDIS"]
-            #[inline]
-            pub fn otepdis(&mut self) -> _OTEPDISW {
-                _OTEPDISW { w: self }
-            }
-            #[doc = "Bit 3 - STUP"]
-            #[inline]
-            pub fn stup(&mut self) -> _STUPW {
-                _STUPW { w: self }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&mut self) -> _EPDISDW {
-                _EPDISDW { w: self }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-1 interrupt register"]
-    pub struct DOEPINT1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-1 interrupt register"]
-    pub mod doepint1 {
-        #[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::DOEPINT1 {
-            #[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 = r" Value of the field"]
-        pub struct B2BSTUPR {
-            bits: bool,
-        }
-        impl B2BSTUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OTEPDISR {
-            bits: bool,
-        }
-        impl OTEPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STUPR {
-            bits: bool,
-        }
-        impl STUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISDR {
-            bits: bool,
-        }
-        impl EPDISDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _B2BSTUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _B2BSTUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OTEPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTEPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDISDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - B2BSTUP"]
-            #[inline]
-            pub fn b2bstup(&self) -> B2BSTUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                B2BSTUPR { bits }
-            }
-            #[doc = "Bit 4 - OTEPDIS"]
-            #[inline]
-            pub fn otepdis(&self) -> OTEPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTEPDISR { bits }
-            }
-            #[doc = "Bit 3 - STUP"]
-            #[inline]
-            pub fn stup(&self) -> STUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STUPR { bits }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&self) -> EPDISDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISDR { bits }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x80 }
-            }
-            #[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 6 - B2BSTUP"]
-            #[inline]
-            pub fn b2bstup(&mut self) -> _B2BSTUPW {
-                _B2BSTUPW { w: self }
-            }
-            #[doc = "Bit 4 - OTEPDIS"]
-            #[inline]
-            pub fn otepdis(&mut self) -> _OTEPDISW {
-                _OTEPDISW { w: self }
-            }
-            #[doc = "Bit 3 - STUP"]
-            #[inline]
-            pub fn stup(&mut self) -> _STUPW {
-                _STUPW { w: self }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&mut self) -> _EPDISDW {
-                _EPDISDW { w: self }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-2 interrupt register"]
-    pub struct DOEPINT2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-2 interrupt register"]
-    pub mod doepint2 {
-        #[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::DOEPINT2 {
-            #[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 = r" Value of the field"]
-        pub struct B2BSTUPR {
-            bits: bool,
-        }
-        impl B2BSTUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OTEPDISR {
-            bits: bool,
-        }
-        impl OTEPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STUPR {
-            bits: bool,
-        }
-        impl STUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISDR {
-            bits: bool,
-        }
-        impl EPDISDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _B2BSTUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _B2BSTUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OTEPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTEPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDISDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - B2BSTUP"]
-            #[inline]
-            pub fn b2bstup(&self) -> B2BSTUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                B2BSTUPR { bits }
-            }
-            #[doc = "Bit 4 - OTEPDIS"]
-            #[inline]
-            pub fn otepdis(&self) -> OTEPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTEPDISR { bits }
-            }
-            #[doc = "Bit 3 - STUP"]
-            #[inline]
-            pub fn stup(&self) -> STUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STUPR { bits }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&self) -> EPDISDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISDR { bits }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x80 }
-            }
-            #[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 6 - B2BSTUP"]
-            #[inline]
-            pub fn b2bstup(&mut self) -> _B2BSTUPW {
-                _B2BSTUPW { w: self }
-            }
-            #[doc = "Bit 4 - OTEPDIS"]
-            #[inline]
-            pub fn otepdis(&mut self) -> _OTEPDISW {
-                _OTEPDISW { w: self }
-            }
-            #[doc = "Bit 3 - STUP"]
-            #[inline]
-            pub fn stup(&mut self) -> _STUPW {
-                _STUPW { w: self }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&mut self) -> _EPDISDW {
-                _EPDISDW { w: self }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-3 interrupt register"]
-    pub struct DOEPINT3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-3 interrupt register"]
-    pub mod doepint3 {
-        #[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::DOEPINT3 {
-            #[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 = r" Value of the field"]
-        pub struct B2BSTUPR {
-            bits: bool,
-        }
-        impl B2BSTUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OTEPDISR {
-            bits: bool,
-        }
-        impl OTEPDISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct STUPR {
-            bits: bool,
-        }
-        impl STUPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EPDISDR {
-            bits: bool,
-        }
-        impl EPDISDR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRCR {
-            bits: bool,
-        }
-        impl XFRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _B2BSTUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _B2BSTUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OTEPDISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OTEPDISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _STUPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STUPW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EPDISDW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EPDISDW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRCW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - B2BSTUP"]
-            #[inline]
-            pub fn b2bstup(&self) -> B2BSTUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                B2BSTUPR { bits }
-            }
-            #[doc = "Bit 4 - OTEPDIS"]
-            #[inline]
-            pub fn otepdis(&self) -> OTEPDISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OTEPDISR { bits }
-            }
-            #[doc = "Bit 3 - STUP"]
-            #[inline]
-            pub fn stup(&self) -> STUPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STUPR { bits }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&self) -> EPDISDR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EPDISDR { bits }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&self) -> XFRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                XFRCR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x80 }
-            }
-            #[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 6 - B2BSTUP"]
-            #[inline]
-            pub fn b2bstup(&mut self) -> _B2BSTUPW {
-                _B2BSTUPW { w: self }
-            }
-            #[doc = "Bit 4 - OTEPDIS"]
-            #[inline]
-            pub fn otepdis(&mut self) -> _OTEPDISW {
-                _OTEPDISW { w: self }
-            }
-            #[doc = "Bit 3 - STUP"]
-            #[inline]
-            pub fn stup(&mut self) -> _STUPW {
-                _STUPW { w: self }
-            }
-            #[doc = "Bit 1 - EPDISD"]
-            #[inline]
-            pub fn epdisd(&mut self) -> _EPDISDW {
-                _EPDISDW { w: self }
-            }
-            #[doc = "Bit 0 - XFRC"]
-            #[inline]
-            pub fn xfrc(&mut self) -> _XFRCW {
-                _XFRCW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-0 transfer size register"]
-    pub struct DIEPTSIZ0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-0 transfer size register"]
-    pub mod dieptsiz0 {
-        #[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::DIEPTSIZ0 {
-            #[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 = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u8,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u8,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                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 19:20 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 0:6 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                XFRSIZR { bits }
-            }
-        }
-        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 19:20 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 0:6 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device OUT endpoint-0 transfer size register"]
-    pub struct DOEPTSIZ0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device OUT endpoint-0 transfer size register"]
-    pub mod doeptsiz0 {
-        #[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::DOEPTSIZ0 {
-            #[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 = r" Value of the field"]
-        pub struct STUPCNTR {
-            bits: u8,
-        }
-        impl STUPCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: bool,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct XFRSIZR {
-            bits: u8,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _STUPCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STUPCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                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 29:30 - SETUP packet count"]
-            #[inline]
-            pub fn stupcnt(&self) -> STUPCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                STUPCNTR { bits }
-            }
-            #[doc = "Bit 19 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 0:6 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                XFRSIZR { bits }
-            }
-        }
-        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 29:30 - SETUP packet count"]
-            #[inline]
-            pub fn stupcnt(&mut self) -> _STUPCNTW {
-                _STUPCNTW { w: self }
-            }
-            #[doc = "Bit 19 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 0:6 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-1 transfer size register"]
-    pub struct DIEPTSIZ1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-1 transfer size register"]
-    pub mod dieptsiz1 {
-        #[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::DIEPTSIZ1 {
-            #[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 = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                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 29:30 - Multi count"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-        }
-        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 29:30 - Multi count"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-2 transfer size register"]
-    pub struct DIEPTSIZ2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-2 transfer size register"]
-    pub mod dieptsiz2 {
-        #[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::DIEPTSIZ2 {
-            #[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 = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                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 29:30 - Multi count"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-        }
-        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 29:30 - Multi count"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device endpoint-3 transfer size register"]
-    pub struct DIEPTSIZ3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device endpoint-3 transfer size register"]
-    pub mod dieptsiz3 {
-        #[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::DIEPTSIZ3 {
-            #[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 = r" Value of the field"]
-        pub struct MCNTR {
-            bits: u8,
-        }
-        impl MCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                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 29:30 - Multi count"]
-            #[inline]
-            pub fn mcnt(&self) -> MCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCNTR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-        }
-        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 29:30 - Multi count"]
-            #[inline]
-            pub fn mcnt(&mut self) -> _MCNTW {
-                _MCNTW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO status register"]
-    pub struct DTXFSTS0 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO status register"]
-    pub mod dtxfsts0 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DTXFSTS0 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INEPTFSAVR {
-            bits: u16,
-        }
-        impl INEPTFSAVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - IN endpoint TxFIFO space available"]
-            #[inline]
-            pub fn ineptfsav(&self) -> INEPTFSAVR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTFSAVR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO status register"]
-    pub struct DTXFSTS1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO status register"]
-    pub mod dtxfsts1 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DTXFSTS1 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INEPTFSAVR {
-            bits: u16,
-        }
-        impl INEPTFSAVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - IN endpoint TxFIFO space available"]
-            #[inline]
-            pub fn ineptfsav(&self) -> INEPTFSAVR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTFSAVR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO status register"]
-    pub struct DTXFSTS2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO status register"]
-    pub mod dtxfsts2 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DTXFSTS2 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INEPTFSAVR {
-            bits: u16,
-        }
-        impl INEPTFSAVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - IN endpoint TxFIFO space available"]
-            #[inline]
-            pub fn ineptfsav(&self) -> INEPTFSAVR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTFSAVR { bits }
-            }
-        }
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO status register"]
-    pub struct DTXFSTS3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS device IN endpoint transmit FIFO status register"]
-    pub mod dtxfsts3 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DTXFSTS3 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INEPTFSAVR {
-            bits: u16,
-        }
-        impl INEPTFSAVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - IN endpoint TxFIFO space available"]
-            #[inline]
-            pub fn ineptfsav(&self) -> INEPTFSAVR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INEPTFSAVR { bits }
-            }
-        }
-    }
-    #[doc = "device OUT endpoint-1 transfer size register"]
-    pub struct DOEPTSIZ1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device OUT endpoint-1 transfer size register"]
-    pub mod doeptsiz1 {
-        #[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::DOEPTSIZ1 {
-            #[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 = r" Value of the field"]
-        pub struct RXDPID_STUPCNTR {
-            bits: u8,
-        }
-        impl RXDPID_STUPCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RXDPID_STUPCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXDPID_STUPCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                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 29:30 - Received data PID/SETUP packet count"]
-            #[inline]
-            pub fn rxdpid_stupcnt(&self) -> RXDPID_STUPCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RXDPID_STUPCNTR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-        }
-        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 29:30 - Received data PID/SETUP packet count"]
-            #[inline]
-            pub fn rxdpid_stupcnt(&mut self) -> _RXDPID_STUPCNTW {
-                _RXDPID_STUPCNTW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device OUT endpoint-2 transfer size register"]
-    pub struct DOEPTSIZ2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device OUT endpoint-2 transfer size register"]
-    pub mod doeptsiz2 {
-        #[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::DOEPTSIZ2 {
-            #[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 = r" Value of the field"]
-        pub struct RXDPID_STUPCNTR {
-            bits: u8,
-        }
-        impl RXDPID_STUPCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RXDPID_STUPCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXDPID_STUPCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                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 29:30 - Received data PID/SETUP packet count"]
-            #[inline]
-            pub fn rxdpid_stupcnt(&self) -> RXDPID_STUPCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RXDPID_STUPCNTR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-        }
-        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 29:30 - Received data PID/SETUP packet count"]
-            #[inline]
-            pub fn rxdpid_stupcnt(&mut self) -> _RXDPID_STUPCNTW {
-                _RXDPID_STUPCNTW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-        }
-    }
-    #[doc = "device OUT endpoint-3 transfer size register"]
-    pub struct DOEPTSIZ3 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device OUT endpoint-3 transfer size register"]
-    pub mod doeptsiz3 {
-        #[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::DOEPTSIZ3 {
-            #[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 = r" Value of the field"]
-        pub struct RXDPID_STUPCNTR {
-            bits: u8,
-        }
-        impl RXDPID_STUPCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PKTCNTR {
-            bits: u16,
-        }
-        impl PKTCNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct XFRSIZR {
-            bits: u32,
-        }
-        impl XFRSIZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _RXDPID_STUPCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _RXDPID_STUPCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 29;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PKTCNTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PKTCNTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x03ff;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _XFRSIZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _XFRSIZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0x0007_ffff;
-                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 29:30 - Received data PID/SETUP packet count"]
-            #[inline]
-            pub fn rxdpid_stupcnt(&self) -> RXDPID_STUPCNTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                RXDPID_STUPCNTR { bits }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&self) -> PKTCNTR {
-                let bits = {
-                    const MASK: u16 = 0x03ff;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                PKTCNTR { bits }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&self) -> XFRSIZR {
-                let bits = {
-                    const MASK: u32 = 0x0007_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                XFRSIZR { bits }
-            }
-        }
-        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 29:30 - Received data PID/SETUP packet count"]
-            #[inline]
-            pub fn rxdpid_stupcnt(&mut self) -> _RXDPID_STUPCNTW {
-                _RXDPID_STUPCNTW { w: self }
-            }
-            #[doc = "Bits 19:28 - Packet count"]
-            #[inline]
-            pub fn pktcnt(&mut self) -> _PKTCNTW {
-                _PKTCNTW { w: self }
-            }
-            #[doc = "Bits 0:18 - Transfer size"]
-            #[inline]
-            pub fn xfrsiz(&mut self) -> _XFRSIZW {
-                _XFRSIZW { w: self }
-            }
-        }
-    }
-}
-#[doc = "USB on the go full speed"]
-pub struct OTG_FS_PWRCLK {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for OTG_FS_PWRCLK {}
-impl OTG_FS_PWRCLK {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const otg_fs_pwrclk::RegisterBlock {
-        0x5000_0e00 as *const _
-    }
-}
-impl Deref for OTG_FS_PWRCLK {
-    type Target = otg_fs_pwrclk::RegisterBlock;
-    fn deref(&self) -> &otg_fs_pwrclk::RegisterBlock {
-        unsafe { &*OTG_FS_PWRCLK::ptr() }
-    }
-}
-#[doc = "USB on the go full speed"]
-pub mod otg_fs_pwrclk {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - OTG_FS power and clock gating control register (OTG_FS_PCGCCTL)"]
-        pub fs_pcgcctl: FS_PCGCCTL,
-    }
-    #[doc = "OTG_FS power and clock gating control register (OTG_FS_PCGCCTL)"]
-    pub struct FS_PCGCCTL {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "OTG_FS power and clock gating control register (OTG_FS_PCGCCTL)"]
-    pub mod fs_pcgcctl {
-        #[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::FS_PCGCCTL {
-            #[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 = r" Value of the field"]
-        pub struct STPPCLKR {
-            bits: bool,
-        }
-        impl STPPCLKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct GATEHCLKR {
-            bits: bool,
-        }
-        impl GATEHCLKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PHYSUSPR {
-            bits: bool,
-        }
-        impl PHYSUSPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _STPPCLKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _STPPCLKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _GATEHCLKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _GATEHCLKW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PHYSUSPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PHYSUSPW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 0 - Stop PHY clock"]
-            #[inline]
-            pub fn stppclk(&self) -> STPPCLKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                STPPCLKR { bits }
-            }
-            #[doc = "Bit 1 - Gate HCLK"]
-            #[inline]
-            pub fn gatehclk(&self) -> GATEHCLKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                GATEHCLKR { bits }
-            }
-            #[doc = "Bit 4 - PHY Suspended"]
-            #[inline]
-            pub fn physusp(&self) -> PHYSUSPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PHYSUSPR { bits }
-            }
-        }
-        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 - Stop PHY clock"]
-            #[inline]
-            pub fn stppclk(&mut self) -> _STPPCLKW {
-                _STPPCLKW { w: self }
-            }
-            #[doc = "Bit 1 - Gate HCLK"]
-            #[inline]
-            pub fn gatehclk(&mut self) -> _GATEHCLKW {
-                _GATEHCLKW { w: self }
-            }
-            #[doc = "Bit 4 - PHY Suspended"]
-            #[inline]
-            pub fn physusp(&mut self) -> _PHYSUSPW {
-                _PHYSUSPW { w: self }
-            }
-        }
-    }
-}
-#[doc = "QuadSPI interface"]
-pub struct QUADSPI {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for QUADSPI {}
-impl QUADSPI {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const quadspi::RegisterBlock {
-        0xa000_1000 as *const _
-    }
-}
-impl Deref for QUADSPI {
-    type Target = quadspi::RegisterBlock;
-    fn deref(&self) -> &quadspi::RegisterBlock {
-        unsafe { &*QUADSPI::ptr() }
-    }
-}
-#[doc = "QuadSPI interface"]
-pub mod quadspi {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register"]
-        pub cr: CR,
-        #[doc = "0x04 - device configuration register"]
-        pub dcr: DCR,
-        #[doc = "0x08 - status register"]
-        pub sr: SR,
-        #[doc = "0x0c - flag clear register"]
-        pub fcr: FCR,
-        #[doc = "0x10 - data length register"]
-        pub dlr: DLR,
-        #[doc = "0x14 - communication configuration register"]
-        pub ccr: CCR,
-        #[doc = "0x18 - address register"]
-        pub ar: AR,
-        #[doc = "0x1c - ABR"]
-        pub abr: ABR,
-        #[doc = "0x20 - data register"]
-        pub dr: DR,
-        #[doc = "0x24 - polling status mask register"]
-        pub psmkr: PSMKR,
-        #[doc = "0x28 - polling status match register"]
-        pub psmar: PSMAR,
-        #[doc = "0x2c - polling interval register"]
-        pub pir: PIR,
-        #[doc = "0x30 - low-power timeout register"]
-        pub lptr: LPTR,
-    }
-    #[doc = "control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct PRESCALERR {
-            bits: u8,
-        }
-        impl PRESCALERR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PMMR {
-            bits: bool,
-        }
-        impl PMMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct APMSR {
-            bits: bool,
-        }
-        impl APMSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TOIER {
-            bits: bool,
-        }
-        impl TOIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SMIER {
-            bits: bool,
-        }
-        impl SMIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTIER {
-            bits: bool,
-        }
-        impl FTIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCIER {
-            bits: bool,
-        }
-        impl TCIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEIER {
-            bits: bool,
-        }
-        impl TEIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHRESR {
-            bits: u8,
-        }
-        impl FTHRESR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FSELR {
-            bits: bool,
-        }
-        impl FSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DFMR {
-            bits: bool,
-        }
-        impl DFMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SSHIFTR {
-            bits: bool,
-        }
-        impl SSHIFTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCENR {
-            bits: bool,
-        }
-        impl TCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAENR {
-            bits: bool,
-        }
-        impl DMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ABORTR {
-            bits: bool,
-        }
-        impl ABORTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _PRESCALERW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRESCALERW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PMMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PMMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _APMSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _APMSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TOIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TOIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SMIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SMIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TEIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHRESW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHRESW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSELW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DFMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DFMW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SSHIFTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SSHIFTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TCENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ABORTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ABORTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 24:31 - Clock prescaler"]
-            #[inline]
-            pub fn prescaler(&self) -> PRESCALERR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PRESCALERR { bits }
-            }
-            #[doc = "Bit 23 - Polling match mode"]
-            #[inline]
-            pub fn pmm(&self) -> PMMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PMMR { bits }
-            }
-            #[doc = "Bit 22 - Automatic poll mode stop"]
-            #[inline]
-            pub fn apms(&self) -> APMSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                APMSR { bits }
-            }
-            #[doc = "Bit 20 - TimeOut interrupt enable"]
-            #[inline]
-            pub fn toie(&self) -> TOIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TOIER { bits }
-            }
-            #[doc = "Bit 19 - Status match interrupt enable"]
-            #[inline]
-            pub fn smie(&self) -> SMIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMIER { bits }
-            }
-            #[doc = "Bit 18 - FIFO threshold interrupt enable"]
-            #[inline]
-            pub fn ftie(&self) -> FTIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FTIER { bits }
-            }
-            #[doc = "Bit 17 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&self) -> TCIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCIER { bits }
-            }
-            #[doc = "Bit 16 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&self) -> TEIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEIER { bits }
-            }
-            #[doc = "Bits 8:12 - IFO threshold level"]
-            #[inline]
-            pub fn fthres(&self) -> FTHRESR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHRESR { bits }
-            }
-            #[doc = "Bit 7 - FLASH memory selection"]
-            #[inline]
-            pub fn fsel(&self) -> FSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSELR { bits }
-            }
-            #[doc = "Bit 6 - Dual-flash mode"]
-            #[inline]
-            pub fn dfm(&self) -> DFMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DFMR { bits }
-            }
-            #[doc = "Bit 4 - Sample shift"]
-            #[inline]
-            pub fn sshift(&self) -> SSHIFTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SSHIFTR { bits }
-            }
-            #[doc = "Bit 3 - Timeout counter enable"]
-            #[inline]
-            pub fn tcen(&self) -> TCENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCENR { bits }
-            }
-            #[doc = "Bit 2 - DMA enable"]
-            #[inline]
-            pub fn dmaen(&self) -> DMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAENR { bits }
-            }
-            #[doc = "Bit 1 - Abort request"]
-            #[inline]
-            pub fn abort(&self) -> ABORTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ABORTR { bits }
-            }
-            #[doc = "Bit 0 - Enable"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 24:31 - Clock prescaler"]
-            #[inline]
-            pub fn prescaler(&mut self) -> _PRESCALERW {
-                _PRESCALERW { w: self }
-            }
-            #[doc = "Bit 23 - Polling match mode"]
-            #[inline]
-            pub fn pmm(&mut self) -> _PMMW {
-                _PMMW { w: self }
-            }
-            #[doc = "Bit 22 - Automatic poll mode stop"]
-            #[inline]
-            pub fn apms(&mut self) -> _APMSW {
-                _APMSW { w: self }
-            }
-            #[doc = "Bit 20 - TimeOut interrupt enable"]
-            #[inline]
-            pub fn toie(&mut self) -> _TOIEW {
-                _TOIEW { w: self }
-            }
-            #[doc = "Bit 19 - Status match interrupt enable"]
-            #[inline]
-            pub fn smie(&mut self) -> _SMIEW {
-                _SMIEW { w: self }
-            }
-            #[doc = "Bit 18 - FIFO threshold interrupt enable"]
-            #[inline]
-            pub fn ftie(&mut self) -> _FTIEW {
-                _FTIEW { w: self }
-            }
-            #[doc = "Bit 17 - Transfer complete interrupt enable"]
-            #[inline]
-            pub fn tcie(&mut self) -> _TCIEW {
-                _TCIEW { w: self }
-            }
-            #[doc = "Bit 16 - Transfer error interrupt enable"]
-            #[inline]
-            pub fn teie(&mut self) -> _TEIEW {
-                _TEIEW { w: self }
-            }
-            #[doc = "Bits 8:12 - IFO threshold level"]
-            #[inline]
-            pub fn fthres(&mut self) -> _FTHRESW {
-                _FTHRESW { w: self }
-            }
-            #[doc = "Bit 7 - FLASH memory selection"]
-            #[inline]
-            pub fn fsel(&mut self) -> _FSELW {
-                _FSELW { w: self }
-            }
-            #[doc = "Bit 6 - Dual-flash mode"]
-            #[inline]
-            pub fn dfm(&mut self) -> _DFMW {
-                _DFMW { w: self }
-            }
-            #[doc = "Bit 4 - Sample shift"]
-            #[inline]
-            pub fn sshift(&mut self) -> _SSHIFTW {
-                _SSHIFTW { w: self }
-            }
-            #[doc = "Bit 3 - Timeout counter enable"]
-            #[inline]
-            pub fn tcen(&mut self) -> _TCENW {
-                _TCENW { w: self }
-            }
-            #[doc = "Bit 2 - DMA enable"]
-            #[inline]
-            pub fn dmaen(&mut self) -> _DMAENW {
-                _DMAENW { w: self }
-            }
-            #[doc = "Bit 1 - Abort request"]
-            #[inline]
-            pub fn abort(&mut self) -> _ABORTW {
-                _ABORTW { w: self }
-            }
-            #[doc = "Bit 0 - Enable"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "device configuration register"]
-    pub struct DCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "device configuration register"]
-    pub mod dcr {
-        #[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::DCR {
-            #[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 = r" Value of the field"]
-        pub struct FSIZER {
-            bits: u8,
-        }
-        impl FSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CSHTR {
-            bits: u8,
-        }
-        impl CSHTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKMODER {
-            bits: bool,
-        }
-        impl CKMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CSHTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CSHTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKMODEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:20 - FLASH memory size"]
-            #[inline]
-            pub fn fsize(&self) -> FSIZER {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSIZER { bits }
-            }
-            #[doc = "Bits 8:10 - Chip select high time"]
-            #[inline]
-            pub fn csht(&self) -> CSHTR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CSHTR { bits }
-            }
-            #[doc = "Bit 0 - Mode 0 / mode 3"]
-            #[inline]
-            pub fn ckmode(&self) -> CKMODER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKMODER { bits }
-            }
-        }
-        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 16:20 - FLASH memory size"]
-            #[inline]
-            pub fn fsize(&mut self) -> _FSIZEW {
-                _FSIZEW { w: self }
-            }
-            #[doc = "Bits 8:10 - Chip select high time"]
-            #[inline]
-            pub fn csht(&mut self) -> _CSHTW {
-                _CSHTW { w: self }
-            }
-            #[doc = "Bit 0 - Mode 0 / mode 3"]
-            #[inline]
-            pub fn ckmode(&mut self) -> _CKMODEW {
-                _CKMODEW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::SR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FLEVELR {
-            bits: u8,
-        }
-        impl FLEVELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct BUSYR {
-            bits: bool,
-        }
-        impl BUSYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TOFR {
-            bits: bool,
-        }
-        impl TOFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SMFR {
-            bits: bool,
-        }
-        impl SMFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTFR {
-            bits: bool,
-        }
-        impl FTFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TCFR {
-            bits: bool,
-        }
-        impl TCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TEFR {
-            bits: bool,
-        }
-        impl TEFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 8:14 - FIFO level"]
-            #[inline]
-            pub fn flevel(&self) -> FLEVELR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FLEVELR { bits }
-            }
-            #[doc = "Bit 5 - Busy"]
-            #[inline]
-            pub fn busy(&self) -> BUSYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BUSYR { bits }
-            }
-            #[doc = "Bit 4 - Timeout flag"]
-            #[inline]
-            pub fn tof(&self) -> TOFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TOFR { bits }
-            }
-            #[doc = "Bit 3 - Status match flag"]
-            #[inline]
-            pub fn smf(&self) -> SMFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SMFR { bits }
-            }
-            #[doc = "Bit 2 - FIFO threshold flag"]
-            #[inline]
-            pub fn ftf(&self) -> FTFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FTFR { bits }
-            }
-            #[doc = "Bit 1 - Transfer complete flag"]
-            #[inline]
-            pub fn tcf(&self) -> TCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TCFR { bits }
-            }
-            #[doc = "Bit 0 - Transfer error flag"]
-            #[inline]
-            pub fn tef(&self) -> TEFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEFR { bits }
-            }
-        }
-    }
-    #[doc = "flag clear register"]
-    pub struct FCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "flag clear register"]
-    pub mod fcr {
-        #[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::FCR {
-            #[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 = r" Value of the field"]
-        pub struct CTOFR {
-            bits: bool,
-        }
-        impl CTOFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CSMFR {
-            bits: bool,
-        }
-        impl CSMFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTCFR {
-            bits: bool,
-        }
-        impl CTCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CTEFR {
-            bits: bool,
-        }
-        impl CTEFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CTOFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTOFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CSMFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CSMFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CTEFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CTEFW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 4 - Clear timeout flag"]
-            #[inline]
-            pub fn ctof(&self) -> CTOFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTOFR { bits }
-            }
-            #[doc = "Bit 3 - Clear status match flag"]
-            #[inline]
-            pub fn csmf(&self) -> CSMFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CSMFR { bits }
-            }
-            #[doc = "Bit 1 - Clear transfer complete flag"]
-            #[inline]
-            pub fn ctcf(&self) -> CTCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTCFR { bits }
-            }
-            #[doc = "Bit 0 - Clear transfer error flag"]
-            #[inline]
-            pub fn ctef(&self) -> CTEFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CTEFR { bits }
-            }
-        }
-        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 4 - Clear timeout flag"]
-            #[inline]
-            pub fn ctof(&mut self) -> _CTOFW {
-                _CTOFW { w: self }
-            }
-            #[doc = "Bit 3 - Clear status match flag"]
-            #[inline]
-            pub fn csmf(&mut self) -> _CSMFW {
-                _CSMFW { w: self }
-            }
-            #[doc = "Bit 1 - Clear transfer complete flag"]
-            #[inline]
-            pub fn ctcf(&mut self) -> _CTCFW {
-                _CTCFW { w: self }
-            }
-            #[doc = "Bit 0 - Clear transfer error flag"]
-            #[inline]
-            pub fn ctef(&mut self) -> _CTEFW {
-                _CTEFW { w: self }
-            }
-        }
-    }
-    #[doc = "data length register"]
-    pub struct DLR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data length register"]
-    pub mod dlr {
-        #[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::DLR {
-            #[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 = r" Value of the field"]
-        pub struct DLR {
-            bits: u32,
-        }
-        impl DLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Data length"]
-            #[inline]
-            pub fn dl(&self) -> DLR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                DLR { bits }
-            }
-        }
-        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 0:31 - Data length"]
-            #[inline]
-            pub fn dl(&mut self) -> _DLW {
-                _DLW { w: self }
-            }
-        }
-    }
-    #[doc = "communication configuration register"]
-    pub struct CCR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "communication configuration register"]
-    pub mod ccr {
-        #[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::CCR {
-            #[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 = r" Value of the field"]
-        pub struct DDRMR {
-            bits: bool,
-        }
-        impl DDRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DHHCR {
-            bits: bool,
-        }
-        impl DHHCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SIOOR {
-            bits: bool,
-        }
-        impl SIOOR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FMODER {
-            bits: u8,
-        }
-        impl FMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DMODER {
-            bits: u8,
-        }
-        impl DMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DCYCR {
-            bits: u8,
-        }
-        impl DCYCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ABSIZER {
-            bits: u8,
-        }
-        impl ABSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ABMODER {
-            bits: u8,
-        }
-        impl ABMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADSIZER {
-            bits: u8,
-        }
-        impl ADSIZER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ADMODER {
-            bits: u8,
-        }
-        impl ADMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct IMODER {
-            bits: u8,
-        }
-        impl IMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct INSTRUCTIONR {
-            bits: u8,
-        }
-        impl INSTRUCTIONR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DDRMW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DDRMW<'a> {
-            #[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
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DHHCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DHHCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SIOOW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SIOOW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FMODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 26;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DCYCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DCYCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                const OFFSET: u8 = 18;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ABSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ABSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ABMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ABMODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADSIZEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADSIZEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 12;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADMODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _IMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _IMODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INSTRUCTIONW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INSTRUCTIONW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 = "Bit 31 - Double data rate mode"]
-            #[inline]
-            pub fn ddrm(&self) -> DDRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 31;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DDRMR { bits }
-            }
-            #[doc = "Bit 30 - DDR hold half cycle"]
-            #[inline]
-            pub fn dhhc(&self) -> DHHCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 30;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DHHCR { bits }
-            }
-            #[doc = "Bit 28 - Send instruction only once mode"]
-            #[inline]
-            pub fn sioo(&self) -> SIOOR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SIOOR { bits }
-            }
-            #[doc = "Bits 26:27 - Functional mode"]
-            #[inline]
-            pub fn fmode(&self) -> FMODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 26;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FMODER { bits }
-            }
-            #[doc = "Bits 24:25 - Data mode"]
-            #[inline]
-            pub fn dmode(&self) -> DMODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DMODER { bits }
-            }
-            #[doc = "Bits 18:22 - Number of dummy cycles"]
-            #[inline]
-            pub fn dcyc(&self) -> DCYCR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DCYCR { bits }
-            }
-            #[doc = "Bits 16:17 - Alternate bytes size"]
-            #[inline]
-            pub fn absize(&self) -> ABSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ABSIZER { bits }
-            }
-            #[doc = "Bits 14:15 - Alternate bytes mode"]
-            #[inline]
-            pub fn abmode(&self) -> ABMODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ABMODER { bits }
-            }
-            #[doc = "Bits 12:13 - Address size"]
-            #[inline]
-            pub fn adsize(&self) -> ADSIZER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADSIZER { bits }
-            }
-            #[doc = "Bits 10:11 - Address mode"]
-            #[inline]
-            pub fn admode(&self) -> ADMODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                ADMODER { bits }
-            }
-            #[doc = "Bits 8:9 - Instruction mode"]
-            #[inline]
-            pub fn imode(&self) -> IMODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                IMODER { bits }
-            }
-            #[doc = "Bits 0:7 - Instruction"]
-            #[inline]
-            pub fn instruction(&self) -> INSTRUCTIONR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                INSTRUCTIONR { bits }
-            }
-        }
-        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 31 - Double data rate mode"]
-            #[inline]
-            pub fn ddrm(&mut self) -> _DDRMW {
-                _DDRMW { w: self }
-            }
-            #[doc = "Bit 30 - DDR hold half cycle"]
-            #[inline]
-            pub fn dhhc(&mut self) -> _DHHCW {
-                _DHHCW { w: self }
-            }
-            #[doc = "Bit 28 - Send instruction only once mode"]
-            #[inline]
-            pub fn sioo(&mut self) -> _SIOOW {
-                _SIOOW { w: self }
-            }
-            #[doc = "Bits 26:27 - Functional mode"]
-            #[inline]
-            pub fn fmode(&mut self) -> _FMODEW {
-                _FMODEW { w: self }
-            }
-            #[doc = "Bits 24:25 - Data mode"]
-            #[inline]
-            pub fn dmode(&mut self) -> _DMODEW {
-                _DMODEW { w: self }
-            }
-            #[doc = "Bits 18:22 - Number of dummy cycles"]
-            #[inline]
-            pub fn dcyc(&mut self) -> _DCYCW {
-                _DCYCW { w: self }
-            }
-            #[doc = "Bits 16:17 - Alternate bytes size"]
-            #[inline]
-            pub fn absize(&mut self) -> _ABSIZEW {
-                _ABSIZEW { w: self }
-            }
-            #[doc = "Bits 14:15 - Alternate bytes mode"]
-            #[inline]
-            pub fn abmode(&mut self) -> _ABMODEW {
-                _ABMODEW { w: self }
-            }
-            #[doc = "Bits 12:13 - Address size"]
-            #[inline]
-            pub fn adsize(&mut self) -> _ADSIZEW {
-                _ADSIZEW { w: self }
-            }
-            #[doc = "Bits 10:11 - Address mode"]
-            #[inline]
-            pub fn admode(&mut self) -> _ADMODEW {
-                _ADMODEW { w: self }
-            }
-            #[doc = "Bits 8:9 - Instruction mode"]
-            #[inline]
-            pub fn imode(&mut self) -> _IMODEW {
-                _IMODEW { w: self }
-            }
-            #[doc = "Bits 0:7 - Instruction"]
-            #[inline]
-            pub fn instruction(&mut self) -> _INSTRUCTIONW {
-                _INSTRUCTIONW { w: self }
-            }
-        }
-    }
-    #[doc = "address register"]
-    pub struct AR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "address register"]
-    pub mod ar {
-        #[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::AR {
-            #[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 = r" Value of the field"]
-        pub struct ADDRESSR {
-            bits: u32,
-        }
-        impl ADDRESSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ADDRESSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ADDRESSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Address"]
-            #[inline]
-            pub fn address(&self) -> ADDRESSR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                ADDRESSR { bits }
-            }
-        }
-        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 0:31 - Address"]
-            #[inline]
-            pub fn address(&mut self) -> _ADDRESSW {
-                _ADDRESSW { w: self }
-            }
-        }
-    }
-    #[doc = "ABR"]
-    pub struct ABR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "ABR"]
-    pub mod abr {
-        #[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::ABR {
-            #[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 = r" Value of the field"]
-        pub struct ALTERNATER {
-            bits: u32,
-        }
-        impl ALTERNATER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ALTERNATEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ALTERNATEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - ALTERNATE"]
-            #[inline]
-            pub fn alternate(&self) -> ALTERNATER {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                ALTERNATER { bits }
-            }
-        }
-        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 0:31 - ALTERNATE"]
-            #[inline]
-            pub fn alternate(&mut self) -> _ALTERNATEW {
-                _ALTERNATEW { w: self }
-            }
-        }
-    }
-    #[doc = "data register"]
-    pub struct DR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "data register"]
-    pub mod dr {
-        #[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::DR {
-            #[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 = r" Value of the field"]
-        pub struct DATAR {
-            bits: u32,
-        }
-        impl DATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Data"]
-            #[inline]
-            pub fn data(&self) -> DATAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                DATAR { bits }
-            }
-        }
-        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 0:31 - Data"]
-            #[inline]
-            pub fn data(&mut self) -> _DATAW {
-                _DATAW { w: self }
-            }
-        }
-    }
-    #[doc = "polling status mask register"]
-    pub struct PSMKR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "polling status mask register"]
-    pub mod psmkr {
-        #[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::PSMKR {
-            #[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 = r" Value of the field"]
-        pub struct MASKR {
-            bits: u32,
-        }
-        impl MASKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MASKW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MASKW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Status mask"]
-            #[inline]
-            pub fn mask(&self) -> MASKR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                MASKR { bits }
-            }
-        }
-        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 0:31 - Status mask"]
-            #[inline]
-            pub fn mask(&mut self) -> _MASKW {
-                _MASKW { w: self }
-            }
-        }
-    }
-    #[doc = "polling status match register"]
-    pub struct PSMAR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "polling status match register"]
-    pub mod psmar {
-        #[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::PSMAR {
-            #[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 = r" Value of the field"]
-        pub struct MATCHR {
-            bits: u32,
-        }
-        impl MATCHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MATCHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MATCHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Status match"]
-            #[inline]
-            pub fn match_(&self) -> MATCHR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                MATCHR { bits }
-            }
-        }
-        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 0:31 - Status match"]
-            #[inline]
-            pub fn match_(&mut self) -> _MATCHW {
-                _MATCHW { w: self }
-            }
-        }
-    }
-    #[doc = "polling interval register"]
-    pub struct PIR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "polling interval register"]
-    pub mod pir {
-        #[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::PIR {
-            #[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 = r" Value of the field"]
-        pub struct INTERVALR {
-            bits: u16,
-        }
-        impl INTERVALR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _INTERVALW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _INTERVALW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Polling interval"]
-            #[inline]
-            pub fn interval(&self) -> INTERVALR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                INTERVALR { bits }
-            }
-        }
-        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 0:15 - Polling interval"]
-            #[inline]
-            pub fn interval(&mut self) -> _INTERVALW {
-                _INTERVALW { w: self }
-            }
-        }
-    }
-    #[doc = "low-power timeout register"]
-    pub struct LPTR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "low-power timeout register"]
-    pub mod lptr {
-        #[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::LPTR {
-            #[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 = r" Value of the field"]
-        pub struct TIMEOUTR {
-            bits: u16,
-        }
-        impl TIMEOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TIMEOUTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMEOUTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Timeout period"]
-            #[inline]
-            pub fn timeout(&self) -> TIMEOUTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                TIMEOUTR { bits }
-            }
-        }
-        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 0:15 - Timeout period"]
-            #[inline]
-            pub fn timeout(&mut self) -> _TIMEOUTW {
-                _TIMEOUTW { w: self }
-            }
-        }
-    }
-}
-#[doc = "Low power timer"]
-pub struct LPTIM {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for LPTIM {}
-impl LPTIM {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const lptim::RegisterBlock {
-        0x4000_2400 as *const _
-    }
-}
-impl Deref for LPTIM {
-    type Target = lptim::RegisterBlock;
-    fn deref(&self) -> &lptim::RegisterBlock {
-        unsafe { &*LPTIM::ptr() }
-    }
-}
-#[doc = "Low power timer"]
-pub mod lptim {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - Interrupt and Status Register"]
-        pub isr: ISR,
-        #[doc = "0x04 - Interrupt Clear Register"]
-        pub icr: ICR,
-        #[doc = "0x08 - Interrupt Enable Register"]
-        pub ier: IER,
-        #[doc = "0x0c - Configuration Register"]
-        pub cfgr: CFGR,
-        #[doc = "0x10 - Control Register"]
-        pub cr: CR,
-        #[doc = "0x14 - Compare Register"]
-        pub cmp: CMP,
-        #[doc = "0x18 - Autoreload Register"]
-        pub arr: ARR,
-        #[doc = "0x1c - Counter Register"]
-        pub cnt: CNT,
-    }
-    #[doc = "Interrupt and Status Register"]
-    pub struct ISR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Interrupt and Status Register"]
-    pub mod isr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::ISR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DOWNR {
-            bits: bool,
-        }
-        impl DOWNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UPR {
-            bits: bool,
-        }
-        impl UPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ARROKR {
-            bits: bool,
-        }
-        impl ARROKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMPOKR {
-            bits: bool,
-        }
-        impl CMPOKR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EXTTRIGR {
-            bits: bool,
-        }
-        impl EXTTRIGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ARRMR {
-            bits: bool,
-        }
-        impl ARRMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMPMR {
-            bits: bool,
-        }
-        impl CMPMR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - Counter direction change up to down"]
-            #[inline]
-            pub fn down(&self) -> DOWNR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DOWNR { bits }
-            }
-            #[doc = "Bit 5 - Counter direction change down to up"]
-            #[inline]
-            pub fn up(&self) -> UPR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UPR { bits }
-            }
-            #[doc = "Bit 4 - Autoreload register update OK"]
-            #[inline]
-            pub fn arrok(&self) -> ARROKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARROKR { bits }
-            }
-            #[doc = "Bit 3 - Compare register update OK"]
-            #[inline]
-            pub fn cmpok(&self) -> CMPOKR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMPOKR { bits }
-            }
-            #[doc = "Bit 2 - External trigger edge event"]
-            #[inline]
-            pub fn exttrig(&self) -> EXTTRIGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EXTTRIGR { bits }
-            }
-            #[doc = "Bit 1 - Autoreload match"]
-            #[inline]
-            pub fn arrm(&self) -> ARRMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARRMR { bits }
-            }
-            #[doc = "Bit 0 - Compare match"]
-            #[inline]
-            pub fn cmpm(&self) -> CMPMR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMPMR { bits }
-            }
-        }
-    }
-    #[doc = "Interrupt Clear Register"]
-    pub struct ICR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Interrupt Clear Register"]
-    pub mod icr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::ICR {
-            #[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" Proxy"]
-        pub struct _DOWNCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DOWNCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UPCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UPCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ARROKCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARROKCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMPOKCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMPOKCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EXTTRIGCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTTRIGCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ARRMCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRMCFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMPMCFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMPMCFW<'a> {
-            #[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
-            }
-        }
-        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 6 - Direction change to down Clear Flag"]
-            #[inline]
-            pub fn downcf(&mut self) -> _DOWNCFW {
-                _DOWNCFW { w: self }
-            }
-            #[doc = "Bit 5 - Direction change to UP Clear Flag"]
-            #[inline]
-            pub fn upcf(&mut self) -> _UPCFW {
-                _UPCFW { w: self }
-            }
-            #[doc = "Bit 4 - Autoreload register update OK Clear Flag"]
-            #[inline]
-            pub fn arrokcf(&mut self) -> _ARROKCFW {
-                _ARROKCFW { w: self }
-            }
-            #[doc = "Bit 3 - Compare register update OK Clear Flag"]
-            #[inline]
-            pub fn cmpokcf(&mut self) -> _CMPOKCFW {
-                _CMPOKCFW { w: self }
-            }
-            #[doc = "Bit 2 - External trigger valid edge Clear Flag"]
-            #[inline]
-            pub fn exttrigcf(&mut self) -> _EXTTRIGCFW {
-                _EXTTRIGCFW { w: self }
-            }
-            #[doc = "Bit 1 - Autoreload match Clear Flag"]
-            #[inline]
-            pub fn arrmcf(&mut self) -> _ARRMCFW {
-                _ARRMCFW { w: self }
-            }
-            #[doc = "Bit 0 - compare match Clear Flag"]
-            #[inline]
-            pub fn cmpmcf(&mut self) -> _CMPMCFW {
-                _CMPMCFW { w: self }
-            }
-        }
-    }
-    #[doc = "Interrupt Enable Register"]
-    pub struct IER {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Interrupt Enable Register"]
-    pub mod ier {
-        #[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::IER {
-            #[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 = r" Value of the field"]
-        pub struct DOWNIER {
-            bits: bool,
-        }
-        impl DOWNIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct UPIER {
-            bits: bool,
-        }
-        impl UPIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ARROKIER {
-            bits: bool,
-        }
-        impl ARROKIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMPOKIER {
-            bits: bool,
-        }
-        impl CMPOKIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EXTTRIGIER {
-            bits: bool,
-        }
-        impl EXTTRIGIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ARRMIER {
-            bits: bool,
-        }
-        impl ARRMIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CMPMIER {
-            bits: bool,
-        }
-        impl CMPMIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _DOWNIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DOWNIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _UPIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _UPIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ARROKIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARROKIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMPOKIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMPOKIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EXTTRIGIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EXTTRIGIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ARRMIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRMIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CMPMIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMPMIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - Direction change to down Interrupt Enable"]
-            #[inline]
-            pub fn downie(&self) -> DOWNIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DOWNIER { bits }
-            }
-            #[doc = "Bit 5 - Direction change to UP Interrupt Enable"]
-            #[inline]
-            pub fn upie(&self) -> UPIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                UPIER { bits }
-            }
-            #[doc = "Bit 4 - Autoreload register update OK Interrupt Enable"]
-            #[inline]
-            pub fn arrokie(&self) -> ARROKIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARROKIER { bits }
-            }
-            #[doc = "Bit 3 - Compare register update OK Interrupt Enable"]
-            #[inline]
-            pub fn cmpokie(&self) -> CMPOKIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMPOKIER { bits }
-            }
-            #[doc = "Bit 2 - External trigger valid edge Interrupt Enable"]
-            #[inline]
-            pub fn exttrigie(&self) -> EXTTRIGIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EXTTRIGIER { bits }
-            }
-            #[doc = "Bit 1 - Autoreload match Interrupt Enable"]
-            #[inline]
-            pub fn arrmie(&self) -> ARRMIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ARRMIER { bits }
-            }
-            #[doc = "Bit 0 - Compare match Interrupt Enable"]
-            #[inline]
-            pub fn cmpmie(&self) -> CMPMIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CMPMIER { bits }
-            }
-        }
-        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 6 - Direction change to down Interrupt Enable"]
-            #[inline]
-            pub fn downie(&mut self) -> _DOWNIEW {
-                _DOWNIEW { w: self }
-            }
-            #[doc = "Bit 5 - Direction change to UP Interrupt Enable"]
-            #[inline]
-            pub fn upie(&mut self) -> _UPIEW {
-                _UPIEW { w: self }
-            }
-            #[doc = "Bit 4 - Autoreload register update OK Interrupt Enable"]
-            #[inline]
-            pub fn arrokie(&mut self) -> _ARROKIEW {
-                _ARROKIEW { w: self }
-            }
-            #[doc = "Bit 3 - Compare register update OK Interrupt Enable"]
-            #[inline]
-            pub fn cmpokie(&mut self) -> _CMPOKIEW {
-                _CMPOKIEW { w: self }
-            }
-            #[doc = "Bit 2 - External trigger valid edge Interrupt Enable"]
-            #[inline]
-            pub fn exttrigie(&mut self) -> _EXTTRIGIEW {
-                _EXTTRIGIEW { w: self }
-            }
-            #[doc = "Bit 1 - Autoreload match Interrupt Enable"]
-            #[inline]
-            pub fn arrmie(&mut self) -> _ARRMIEW {
-                _ARRMIEW { w: self }
-            }
-            #[doc = "Bit 0 - Compare match Interrupt Enable"]
-            #[inline]
-            pub fn cmpmie(&mut self) -> _CMPMIEW {
-                _CMPMIEW { w: self }
-            }
-        }
-    }
-    #[doc = "Configuration Register"]
-    pub struct CFGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Configuration Register"]
-    pub mod cfgr {
-        #[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::CFGR {
-            #[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 = r" Value of the field"]
-        pub struct ENCR {
-            bits: bool,
-        }
-        impl ENCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct COUNTMODER {
-            bits: bool,
-        }
-        impl COUNTMODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct PRELOADR {
-            bits: bool,
-        }
-        impl PRELOADR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAVPOLR {
-            bits: bool,
-        }
-        impl WAVPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WAVER {
-            bits: bool,
-        }
-        impl WAVER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TIMOUTR {
-            bits: bool,
-        }
-        impl TIMOUTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TRIGENR {
-            bits: u8,
-        }
-        impl TRIGENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TRIGSELR {
-            bits: u8,
-        }
-        impl TRIGSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PRESCR {
-            bits: u8,
-        }
-        impl PRESCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TRGFLTR {
-            bits: u8,
-        }
-        impl TRGFLTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKFLTR {
-            bits: u8,
-        }
-        impl CKFLTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKPOLR {
-            bits: u8,
-        }
-        impl CKPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKSELR {
-            bits: bool,
-        }
-        impl CKSELR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _ENCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _COUNTMODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COUNTMODEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _PRELOADW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRELOADW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAVPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAVPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WAVEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAVEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TIMOUTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TIMOUTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TRIGENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRIGENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 17;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TRIGSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRIGSELW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 13;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PRESCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRESCW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 9;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TRGFLTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRGFLTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKFLTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKFLTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKPOLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 1;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKSELW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKSELW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 24 - Encoder mode enable"]
-            #[inline]
-            pub fn enc(&self) -> ENCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENCR { bits }
-            }
-            #[doc = "Bit 23 - counter mode enabled"]
-            #[inline]
-            pub fn countmode(&self) -> COUNTMODER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 23;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                COUNTMODER { bits }
-            }
-            #[doc = "Bit 22 - Registers update mode"]
-            #[inline]
-            pub fn preload(&self) -> PRELOADR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                PRELOADR { bits }
-            }
-            #[doc = "Bit 21 - Waveform shape polarity"]
-            #[inline]
-            pub fn wavpol(&self) -> WAVPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 21;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAVPOLR { bits }
-            }
-            #[doc = "Bit 20 - Waveform shape"]
-            #[inline]
-            pub fn wave(&self) -> WAVER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WAVER { bits }
-            }
-            #[doc = "Bit 19 - Timeout enable"]
-            #[inline]
-            pub fn timout(&self) -> TIMOUTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TIMOUTR { bits }
-            }
-            #[doc = "Bits 17:18 - Trigger enable and polarity"]
-            #[inline]
-            pub fn trigen(&self) -> TRIGENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TRIGENR { bits }
-            }
-            #[doc = "Bits 13:15 - Trigger selector"]
-            #[inline]
-            pub fn trigsel(&self) -> TRIGSELR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TRIGSELR { bits }
-            }
-            #[doc = "Bits 9:11 - Clock prescaler"]
-            #[inline]
-            pub fn presc(&self) -> PRESCR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PRESCR { bits }
-            }
-            #[doc = "Bits 6:7 - Configurable digital filter for trigger"]
-            #[inline]
-            pub fn trgflt(&self) -> TRGFLTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TRGFLTR { bits }
-            }
-            #[doc = "Bits 3:4 - Configurable digital filter for external clock"]
-            #[inline]
-            pub fn ckflt(&self) -> CKFLTR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKFLTR { bits }
-            }
-            #[doc = "Bits 1:2 - Clock Polarity"]
-            #[inline]
-            pub fn ckpol(&self) -> CKPOLR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CKPOLR { bits }
-            }
-            #[doc = "Bit 0 - Clock selector"]
-            #[inline]
-            pub fn cksel(&self) -> CKSELR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKSELR { bits }
-            }
-        }
-        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 24 - Encoder mode enable"]
-            #[inline]
-            pub fn enc(&mut self) -> _ENCW {
-                _ENCW { w: self }
-            }
-            #[doc = "Bit 23 - counter mode enabled"]
-            #[inline]
-            pub fn countmode(&mut self) -> _COUNTMODEW {
-                _COUNTMODEW { w: self }
-            }
-            #[doc = "Bit 22 - Registers update mode"]
-            #[inline]
-            pub fn preload(&mut self) -> _PRELOADW {
-                _PRELOADW { w: self }
-            }
-            #[doc = "Bit 21 - Waveform shape polarity"]
-            #[inline]
-            pub fn wavpol(&mut self) -> _WAVPOLW {
-                _WAVPOLW { w: self }
-            }
-            #[doc = "Bit 20 - Waveform shape"]
-            #[inline]
-            pub fn wave(&mut self) -> _WAVEW {
-                _WAVEW { w: self }
-            }
-            #[doc = "Bit 19 - Timeout enable"]
-            #[inline]
-            pub fn timout(&mut self) -> _TIMOUTW {
-                _TIMOUTW { w: self }
-            }
-            #[doc = "Bits 17:18 - Trigger enable and polarity"]
-            #[inline]
-            pub fn trigen(&mut self) -> _TRIGENW {
-                _TRIGENW { w: self }
-            }
-            #[doc = "Bits 13:15 - Trigger selector"]
-            #[inline]
-            pub fn trigsel(&mut self) -> _TRIGSELW {
-                _TRIGSELW { w: self }
-            }
-            #[doc = "Bits 9:11 - Clock prescaler"]
-            #[inline]
-            pub fn presc(&mut self) -> _PRESCW {
-                _PRESCW { w: self }
-            }
-            #[doc = "Bits 6:7 - Configurable digital filter for trigger"]
-            #[inline]
-            pub fn trgflt(&mut self) -> _TRGFLTW {
-                _TRGFLTW { w: self }
-            }
-            #[doc = "Bits 3:4 - Configurable digital filter for external clock"]
-            #[inline]
-            pub fn ckflt(&mut self) -> _CKFLTW {
-                _CKFLTW { w: self }
-            }
-            #[doc = "Bits 1:2 - Clock Polarity"]
-            #[inline]
-            pub fn ckpol(&mut self) -> _CKPOLW {
-                _CKPOLW { w: self }
-            }
-            #[doc = "Bit 0 - Clock selector"]
-            #[inline]
-            pub fn cksel(&mut self) -> _CKSELW {
-                _CKSELW { w: self }
-            }
-        }
-    }
-    #[doc = "Control Register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Control Register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct CNTSTRTR {
-            bits: bool,
-        }
-        impl CNTSTRTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SNGSTRTR {
-            bits: bool,
-        }
-        impl SNGSTRTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ENABLER {
-            bits: bool,
-        }
-        impl ENABLER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _CNTSTRTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNTSTRTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SNGSTRTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SNGSTRTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ENABLEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENABLEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 2 - Timer start in continuous mode"]
-            #[inline]
-            pub fn cntstrt(&self) -> CNTSTRTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CNTSTRTR { bits }
-            }
-            #[doc = "Bit 1 - LPTIM start in single mode"]
-            #[inline]
-            pub fn sngstrt(&self) -> SNGSTRTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SNGSTRTR { bits }
-            }
-            #[doc = "Bit 0 - LPTIM Enable"]
-            #[inline]
-            pub fn enable(&self) -> ENABLER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENABLER { bits }
-            }
-        }
-        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 2 - Timer start in continuous mode"]
-            #[inline]
-            pub fn cntstrt(&mut self) -> _CNTSTRTW {
-                _CNTSTRTW { w: self }
-            }
-            #[doc = "Bit 1 - LPTIM start in single mode"]
-            #[inline]
-            pub fn sngstrt(&mut self) -> _SNGSTRTW {
-                _SNGSTRTW { w: self }
-            }
-            #[doc = "Bit 0 - LPTIM Enable"]
-            #[inline]
-            pub fn enable(&mut self) -> _ENABLEW {
-                _ENABLEW { w: self }
-            }
-        }
-    }
-    #[doc = "Compare Register"]
-    pub struct CMP {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Compare Register"]
-    pub mod cmp {
-        #[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::CMP {
-            #[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 = r" Value of the field"]
-        pub struct CMPR {
-            bits: u16,
-        }
-        impl CMPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CMPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CMPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Compare value"]
-            #[inline]
-            pub fn cmp(&self) -> CMPR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CMPR { bits }
-            }
-        }
-        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 0:15 - Compare value"]
-            #[inline]
-            pub fn cmp(&mut self) -> _CMPW {
-                _CMPW { w: self }
-            }
-        }
-    }
-    #[doc = "Autoreload Register"]
-    pub struct ARR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Autoreload Register"]
-    pub mod arr {
-        #[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::ARR {
-            #[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 = r" Value of the field"]
-        pub struct ARRR {
-            bits: u16,
-        }
-        impl ARRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ARRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ARRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                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 0:15 - Auto reload value"]
-            #[inline]
-            pub fn arr(&self) -> ARRR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                ARRR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x01 }
-            }
-            #[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 0:15 - Auto reload value"]
-            #[inline]
-            pub fn arr(&mut self) -> _ARRW {
-                _ARRW { w: self }
-            }
-        }
-    }
-    #[doc = "Counter Register"]
-    pub struct CNT {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Counter Register"]
-    pub mod cnt {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::CNT {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CNTR {
-            bits: u16,
-        }
-        impl CNTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:15 - Counter value"]
-            #[inline]
-            pub fn cnt(&self) -> CNTR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                CNTR { bits }
-            }
-        }
-    }
-}
-#[doc = "Digital-to-analog converter"]
-pub struct DAC {
-    _marker: PhantomData<*const ()>,
-}
-unsafe impl Send for DAC {}
-impl DAC {
-    #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const dac::RegisterBlock {
-        0x4000_7400 as *const _
-    }
-}
-impl Deref for DAC {
-    type Target = dac::RegisterBlock;
-    fn deref(&self) -> &dac::RegisterBlock {
-        unsafe { &*DAC::ptr() }
-    }
-}
-#[doc = "Digital-to-analog converter"]
-pub mod dac {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register"]
-        pub cr: CR,
-        #[doc = "0x04 - software trigger register"]
-        pub swtrigr: SWTRIGR,
-        #[doc = "0x08 - channel1 12-bit right-aligned data holding register"]
-        pub dhr12r1: DHR12R1,
-        #[doc = "0x0c - channel1 12-bit left aligned data holding register"]
-        pub dhr12l1: DHR12L1,
-        #[doc = "0x10 - channel1 8-bit right aligned data holding register"]
-        pub dhr8r1: DHR8R1,
-        #[doc = "0x14 - channel2 12-bit right aligned data holding register"]
-        pub dhr12r2: DHR12R2,
-        #[doc = "0x18 - channel2 12-bit left aligned data holding register"]
-        pub dhr12l2: DHR12L2,
-        #[doc = "0x1c - channel2 8-bit right-aligned data holding register"]
-        pub dhr8r2: DHR8R2,
-        #[doc = "0x20 - Dual DAC 12-bit right-aligned data holding register"]
-        pub dhr12rd: DHR12RD,
-        #[doc = "0x24 - DUAL DAC 12-bit left aligned data holding register"]
-        pub dhr12ld: DHR12LD,
-        #[doc = "0x28 - DUAL DAC 8-bit right aligned data holding register"]
-        pub dhr8rd: DHR8RD,
-        #[doc = "0x2c - channel1 data output register"]
-        pub dor1: DOR1,
-        #[doc = "0x30 - channel2 data output register"]
-        pub dor2: DOR2,
-        #[doc = "0x34 - status register"]
-        pub sr: SR,
-    }
-    #[doc = "control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct DMAUDRIE2R {
-            bits: bool,
-        }
-        impl DMAUDRIE2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAEN2R {
-            bits: bool,
-        }
-        impl DMAEN2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MAMP2R {
-            bits: u8,
-        }
-        impl MAMP2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct WAVE2R {
-            bits: u8,
-        }
-        impl WAVE2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TSEL2R {
-            bits: u8,
-        }
-        impl TSEL2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TEN2R {
-            bits: bool,
-        }
-        impl TEN2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BOFF2R {
-            bits: bool,
-        }
-        impl BOFF2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EN2R {
-            bits: bool,
-        }
-        impl EN2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAUDRIE1R {
-            bits: bool,
-        }
-        impl DMAUDRIE1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAEN1R {
-            bits: bool,
-        }
-        impl DMAEN1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MAMP1R {
-            bits: u8,
-        }
-        impl MAMP1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct WAVE1R {
-            bits: u8,
-        }
-        impl WAVE1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TSEL1R {
-            bits: u8,
-        }
-        impl TSEL1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct TEN1R {
-            bits: bool,
-        }
-        impl TEN1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct BOFF1R {
-            bits: bool,
-        }
-        impl BOFF1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct EN1R {
-            bits: bool,
-        }
-        impl EN1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _DMAUDRIE2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAUDRIE2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAEN2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAEN2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MAMP2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MAMP2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 24;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WAVE2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAVE2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 22;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TSEL2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSEL2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 19;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TEN2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEN2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BOFF2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BOFF2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EN2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EN2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAUDRIE1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAUDRIE1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAEN1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAEN1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MAMP1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MAMP1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _WAVE1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WAVE1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TSEL1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TSEL1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _TEN1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TEN1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _BOFF1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _BOFF1W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _EN1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _EN1W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 29 - DAC channel2 DMA underrun interrupt enable"]
-            #[inline]
-            pub fn dmaudrie2(&self) -> DMAUDRIE2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAUDRIE2R { bits }
-            }
-            #[doc = "Bit 28 - DAC channel2 DMA enable"]
-            #[inline]
-            pub fn dmaen2(&self) -> DMAEN2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 28;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAEN2R { bits }
-            }
-            #[doc = "Bits 24:27 - DAC channel2 mask/amplitude selector"]
-            #[inline]
-            pub fn mamp2(&self) -> MAMP2R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 24;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MAMP2R { bits }
-            }
-            #[doc = "Bits 22:23 - DAC channel2 noise/triangle wave generation enable"]
-            #[inline]
-            pub fn wave2(&self) -> WAVE2R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 22;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                WAVE2R { bits }
-            }
-            #[doc = "Bits 19:21 - DAC channel2 trigger selection"]
-            #[inline]
-            pub fn tsel2(&self) -> TSEL2R {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TSEL2R { bits }
-            }
-            #[doc = "Bit 18 - DAC channel2 trigger enable"]
-            #[inline]
-            pub fn ten2(&self) -> TEN2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEN2R { bits }
-            }
-            #[doc = "Bit 17 - DAC channel2 output buffer disable"]
-            #[inline]
-            pub fn boff2(&self) -> BOFF2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BOFF2R { bits }
-            }
-            #[doc = "Bit 16 - DAC channel2 enable"]
-            #[inline]
-            pub fn en2(&self) -> EN2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EN2R { bits }
-            }
-            #[doc = "Bit 13 - DAC channel1 DMA Underrun Interrupt enable"]
-            #[inline]
-            pub fn dmaudrie1(&self) -> DMAUDRIE1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAUDRIE1R { bits }
-            }
-            #[doc = "Bit 12 - DAC channel1 DMA enable"]
-            #[inline]
-            pub fn dmaen1(&self) -> DMAEN1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAEN1R { bits }
-            }
-            #[doc = "Bits 8:11 - DAC channel1 mask/amplitude selector"]
-            #[inline]
-            pub fn mamp1(&self) -> MAMP1R {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MAMP1R { bits }
-            }
-            #[doc = "Bits 6:7 - DAC channel1 noise/triangle wave generation enable"]
-            #[inline]
-            pub fn wave1(&self) -> WAVE1R {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                WAVE1R { bits }
-            }
-            #[doc = "Bits 3:5 - DAC channel1 trigger selection"]
-            #[inline]
-            pub fn tsel1(&self) -> TSEL1R {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                TSEL1R { bits }
-            }
-            #[doc = "Bit 2 - DAC channel1 trigger enable"]
-            #[inline]
-            pub fn ten1(&self) -> TEN1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TEN1R { bits }
-            }
-            #[doc = "Bit 1 - DAC channel1 output buffer disable"]
-            #[inline]
-            pub fn boff1(&self) -> BOFF1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                BOFF1R { bits }
-            }
-            #[doc = "Bit 0 - DAC channel1 enable"]
-            #[inline]
-            pub fn en1(&self) -> EN1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                EN1R { bits }
-            }
-        }
-        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 29 - DAC channel2 DMA underrun interrupt enable"]
-            #[inline]
-            pub fn dmaudrie2(&mut self) -> _DMAUDRIE2W {
-                _DMAUDRIE2W { w: self }
-            }
-            #[doc = "Bit 28 - DAC channel2 DMA enable"]
-            #[inline]
-            pub fn dmaen2(&mut self) -> _DMAEN2W {
-                _DMAEN2W { w: self }
-            }
-            #[doc = "Bits 24:27 - DAC channel2 mask/amplitude selector"]
-            #[inline]
-            pub fn mamp2(&mut self) -> _MAMP2W {
-                _MAMP2W { w: self }
-            }
-            #[doc = "Bits 22:23 - DAC channel2 noise/triangle wave generation enable"]
-            #[inline]
-            pub fn wave2(&mut self) -> _WAVE2W {
-                _WAVE2W { w: self }
-            }
-            #[doc = "Bits 19:21 - DAC channel2 trigger selection"]
-            #[inline]
-            pub fn tsel2(&mut self) -> _TSEL2W {
-                _TSEL2W { w: self }
-            }
-            #[doc = "Bit 18 - DAC channel2 trigger enable"]
-            #[inline]
-            pub fn ten2(&mut self) -> _TEN2W {
-                _TEN2W { w: self }
-            }
-            #[doc = "Bit 17 - DAC channel2 output buffer disable"]
-            #[inline]
-            pub fn boff2(&mut self) -> _BOFF2W {
-                _BOFF2W { w: self }
-            }
-            #[doc = "Bit 16 - DAC channel2 enable"]
-            #[inline]
-            pub fn en2(&mut self) -> _EN2W {
-                _EN2W { w: self }
-            }
-            #[doc = "Bit 13 - DAC channel1 DMA Underrun Interrupt enable"]
-            #[inline]
-            pub fn dmaudrie1(&mut self) -> _DMAUDRIE1W {
-                _DMAUDRIE1W { w: self }
-            }
-            #[doc = "Bit 12 - DAC channel1 DMA enable"]
-            #[inline]
-            pub fn dmaen1(&mut self) -> _DMAEN1W {
-                _DMAEN1W { w: self }
-            }
-            #[doc = "Bits 8:11 - DAC channel1 mask/amplitude selector"]
-            #[inline]
-            pub fn mamp1(&mut self) -> _MAMP1W {
-                _MAMP1W { w: self }
-            }
-            #[doc = "Bits 6:7 - DAC channel1 noise/triangle wave generation enable"]
-            #[inline]
-            pub fn wave1(&mut self) -> _WAVE1W {
-                _WAVE1W { w: self }
-            }
-            #[doc = "Bits 3:5 - DAC channel1 trigger selection"]
-            #[inline]
-            pub fn tsel1(&mut self) -> _TSEL1W {
-                _TSEL1W { w: self }
-            }
-            #[doc = "Bit 2 - DAC channel1 trigger enable"]
-            #[inline]
-            pub fn ten1(&mut self) -> _TEN1W {
-                _TEN1W { w: self }
-            }
-            #[doc = "Bit 1 - DAC channel1 output buffer disable"]
-            #[inline]
-            pub fn boff1(&mut self) -> _BOFF1W {
-                _BOFF1W { w: self }
-            }
-            #[doc = "Bit 0 - DAC channel1 enable"]
-            #[inline]
-            pub fn en1(&mut self) -> _EN1W {
-                _EN1W { w: self }
-            }
-        }
-    }
-    #[doc = "software trigger register"]
-    pub struct SWTRIGR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "software trigger register"]
-    pub mod swtrigr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::SWTRIGR {
-            #[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" Proxy"]
-        pub struct _SWTRIG2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWTRIG2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SWTRIG1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SWTRIG1W<'a> {
-            #[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
-            }
-        }
-        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 1 - DAC channel2 software trigger"]
-            #[inline]
-            pub fn swtrig2(&mut self) -> _SWTRIG2W {
-                _SWTRIG2W { w: self }
-            }
-            #[doc = "Bit 0 - DAC channel1 software trigger"]
-            #[inline]
-            pub fn swtrig1(&mut self) -> _SWTRIG1W {
-                _SWTRIG1W { w: self }
-            }
-        }
-    }
-    #[doc = "channel1 12-bit right-aligned data holding register"]
-    pub struct DHR12R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel1 12-bit right-aligned data holding register"]
-    pub mod dhr12r1 {
-        #[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::DHR12R1 {
-            #[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 = r" Value of the field"]
-        pub struct DACC1DHRR {
-            bits: u16,
-        }
-        impl DACC1DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC1DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC1DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - DAC channel1 12-bit right-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&self) -> DACC1DHRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC1DHRR { bits }
-            }
-        }
-        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 0:11 - DAC channel1 12-bit right-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&mut self) -> _DACC1DHRW {
-                _DACC1DHRW { w: self }
-            }
-        }
-    }
-    #[doc = "channel1 12-bit left aligned data holding register"]
-    pub struct DHR12L1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel1 12-bit left aligned data holding register"]
-    pub mod dhr12l1 {
-        #[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::DHR12L1 {
-            #[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 = r" Value of the field"]
-        pub struct DACC1DHRR {
-            bits: u16,
-        }
-        impl DACC1DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC1DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC1DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 4;
-                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 4:15 - DAC channel1 12-bit left-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&self) -> DACC1DHRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC1DHRR { bits }
-            }
-        }
-        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 4:15 - DAC channel1 12-bit left-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&mut self) -> _DACC1DHRW {
-                _DACC1DHRW { w: self }
-            }
-        }
-    }
-    #[doc = "channel1 8-bit right aligned data holding register"]
-    pub struct DHR8R1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel1 8-bit right aligned data holding register"]
-    pub mod dhr8r1 {
-        #[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::DHR8R1 {
-            #[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 = r" Value of the field"]
-        pub struct DACC1DHRR {
-            bits: u8,
-        }
-        impl DACC1DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC1DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC1DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - DAC channel1 8-bit right-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&self) -> DACC1DHRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DACC1DHRR { bits }
-            }
-        }
-        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 0:7 - DAC channel1 8-bit right-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&mut self) -> _DACC1DHRW {
-                _DACC1DHRW { w: self }
-            }
-        }
-    }
-    #[doc = "channel2 12-bit right aligned data holding register"]
-    pub struct DHR12R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel2 12-bit right aligned data holding register"]
-    pub mod dhr12r2 {
-        #[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::DHR12R2 {
-            #[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 = r" Value of the field"]
-        pub struct DACC2DHRR {
-            bits: u16,
-        }
-        impl DACC2DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC2DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC2DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 0:11 - DAC channel2 12-bit right-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&self) -> DACC2DHRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC2DHRR { bits }
-            }
-        }
-        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 0:11 - DAC channel2 12-bit right-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&mut self) -> _DACC2DHRW {
-                _DACC2DHRW { w: self }
-            }
-        }
-    }
-    #[doc = "channel2 12-bit left aligned data holding register"]
-    pub struct DHR12L2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel2 12-bit left aligned data holding register"]
-    pub mod dhr12l2 {
-        #[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::DHR12L2 {
-            #[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 = r" Value of the field"]
-        pub struct DACC2DHRR {
-            bits: u16,
-        }
-        impl DACC2DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC2DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC2DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 4;
-                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 4:15 - DAC channel2 12-bit left-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&self) -> DACC2DHRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC2DHRR { bits }
-            }
-        }
-        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 4:15 - DAC channel2 12-bit left-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&mut self) -> _DACC2DHRW {
-                _DACC2DHRW { w: self }
-            }
-        }
-    }
-    #[doc = "channel2 8-bit right-aligned data holding register"]
-    pub struct DHR8R2 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "channel2 8-bit right-aligned data holding register"]
-    pub mod dhr8r2 {
-        #[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::DHR8R2 {
-            #[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 = r" Value of the field"]
-        pub struct DACC2DHRR {
-            bits: u8,
-        }
-        impl DACC2DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC2DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC2DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 0:7 - DAC channel2 8-bit right-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&self) -> DACC2DHRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DACC2DHRR { bits }
-            }
-        }
-        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 0:7 - DAC channel2 8-bit right-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&mut self) -> _DACC2DHRW {
-                _DACC2DHRW { w: self }
-            }
-        }
-    }
-    #[doc = "Dual DAC 12-bit right-aligned data holding register"]
-    pub struct DHR12RD {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "Dual DAC 12-bit right-aligned data holding register"]
-    pub mod dhr12rd {
-        #[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::DHR12RD {
-            #[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 = r" Value of the field"]
-        pub struct DACC2DHRR {
-            bits: u16,
-        }
-        impl DACC2DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DACC1DHRR {
-            bits: u16,
-        }
-        impl DACC1DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC2DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC2DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC1DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC1DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                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 16:27 - DAC channel2 12-bit right-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&self) -> DACC2DHRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC2DHRR { bits }
-            }
-            #[doc = "Bits 0:11 - DAC channel1 12-bit right-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&self) -> DACC1DHRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC1DHRR { bits }
-            }
-        }
-        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 16:27 - DAC channel2 12-bit right-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&mut self) -> _DACC2DHRW {
-                _DACC2DHRW { w: self }
-            }
-            #[doc = "Bits 0:11 - DAC channel1 12-bit right-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&mut self) -> _DACC1DHRW {
-                _DACC1DHRW { w: self }
-            }
-        }
-    }
-    #[doc = "DUAL DAC 12-bit left aligned data holding register"]
-    pub struct DHR12LD {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "DUAL DAC 12-bit left aligned data holding register"]
-    pub mod dhr12ld {
-        #[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::DHR12LD {
-            #[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 = r" Value of the field"]
-        pub struct DACC2DHRR {
-            bits: u16,
-        }
-        impl DACC2DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DACC1DHRR {
-            bits: u16,
-        }
-        impl DACC1DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC2DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC2DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC1DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC1DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0x0fff;
-                const OFFSET: u8 = 4;
-                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 20:31 - DAC channel2 12-bit left-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&self) -> DACC2DHRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC2DHRR { bits }
-            }
-            #[doc = "Bits 4:15 - DAC channel1 12-bit left-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&self) -> DACC1DHRR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC1DHRR { bits }
-            }
-        }
-        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 20:31 - DAC channel2 12-bit left-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&mut self) -> _DACC2DHRW {
-                _DACC2DHRW { w: self }
-            }
-            #[doc = "Bits 4:15 - DAC channel1 12-bit left-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&mut self) -> _DACC1DHRW {
-                _DACC1DHRW { w: self }
-            }
-        }
-    }
-    #[doc = "DUAL DAC 8-bit right aligned data holding register"]
-    pub struct DHR8RD {
-        register: VolatileCell<u32>,
+}
+#[doc = "GPIOC"]
+pub struct GPIOC {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for GPIOC {}
+impl GPIOC {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const gpioh::RegisterBlock {
+        1073874944 as *const _
     }
-    #[doc = "DUAL DAC 8-bit right aligned data holding register"]
-    pub mod dhr8rd {
-        #[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::DHR8RD {
-            #[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 = r" Value of the field"]
-        pub struct DACC2DHRR {
-            bits: u8,
-        }
-        impl DACC2DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DACC1DHRR {
-            bits: u8,
-        }
-        impl DACC1DHRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC2DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC2DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DACC1DHRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DACC1DHRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 8:15 - DAC channel2 8-bit right-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&self) -> DACC2DHRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DACC2DHRR { bits }
-            }
-            #[doc = "Bits 0:7 - DAC channel1 8-bit right-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&self) -> DACC1DHRR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DACC1DHRR { bits }
-            }
-        }
-        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 8:15 - DAC channel2 8-bit right-aligned data"]
-            #[inline]
-            pub fn dacc2dhr(&mut self) -> _DACC2DHRW {
-                _DACC2DHRW { w: self }
-            }
-            #[doc = "Bits 0:7 - DAC channel1 8-bit right-aligned data"]
-            #[inline]
-            pub fn dacc1dhr(&mut self) -> _DACC1DHRW {
-                _DACC1DHRW { w: self }
-            }
-        }
+}
+impl Deref for GPIOC {
+    type Target = gpioh::RegisterBlock;
+    fn deref(&self) -> &gpioh::RegisterBlock {
+        unsafe { &*GPIOC::ptr() }
     }
-    #[doc = "channel1 data output register"]
-    pub struct DOR1 {
-        register: VolatileCell<u32>,
+}
+#[doc = "GPIOF"]
+pub struct GPIOF {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for GPIOF {}
+impl GPIOF {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const gpioh::RegisterBlock {
+        1073878016 as *const _
     }
-    #[doc = "channel1 data output register"]
-    pub mod dor1 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DOR1 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DACC1DORR {
-            bits: u16,
-        }
-        impl DACC1DORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:11 - DAC channel1 data output"]
-            #[inline]
-            pub fn dacc1dor(&self) -> DACC1DORR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC1DORR { bits }
-            }
-        }
+}
+impl Deref for GPIOF {
+    type Target = gpioh::RegisterBlock;
+    fn deref(&self) -> &gpioh::RegisterBlock {
+        unsafe { &*GPIOF::ptr() }
     }
-    #[doc = "channel2 data output register"]
-    pub struct DOR2 {
-        register: VolatileCell<u32>,
+}
+#[doc = "GPIOG"]
+pub struct GPIOG {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for GPIOG {}
+impl GPIOG {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const gpioh::RegisterBlock {
+        1073879040 as *const _
     }
-    #[doc = "channel2 data output register"]
-    pub mod dor2 {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DOR2 {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DACC2DORR {
-            bits: u16,
-        }
-        impl DACC2DORR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:11 - DAC channel2 data output"]
-            #[inline]
-            pub fn dacc2dor(&self) -> DACC2DORR {
-                let bits = {
-                    const MASK: u16 = 0x0fff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                DACC2DORR { bits }
-            }
-        }
+}
+impl Deref for GPIOG {
+    type Target = gpioh::RegisterBlock;
+    fn deref(&self) -> &gpioh::RegisterBlock {
+        unsafe { &*GPIOG::ptr() }
     }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
+}
+#[doc = "General-purpose I/Os"]
+pub struct GPIOB {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for GPIOB {}
+impl GPIOB {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const gpiob::RegisterBlock {
+        1073873920 as *const _
     }
-    #[doc = "status register"]
-    pub mod sr {
-        #[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::SR {
-            #[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 = r" Value of the field"]
-        pub struct DMAUDR2R {
-            bits: bool,
-        }
-        impl DMAUDR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAUDR1R {
-            bits: bool,
-        }
-        impl DMAUDR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _DMAUDR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAUDR2W<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAUDR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAUDR1W<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 29 - DAC channel2 DMA underrun flag"]
-            #[inline]
-            pub fn dmaudr2(&self) -> DMAUDR2R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 29;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAUDR2R { bits }
-            }
-            #[doc = "Bit 13 - DAC channel1 DMA underrun flag"]
-            #[inline]
-            pub fn dmaudr1(&self) -> DMAUDR1R {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAUDR1R { bits }
-            }
-        }
-        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 29 - DAC channel2 DMA underrun flag"]
-            #[inline]
-            pub fn dmaudr2(&mut self) -> _DMAUDR2W {
-                _DMAUDR2W { w: self }
-            }
-            #[doc = "Bit 13 - DAC channel1 DMA underrun flag"]
-            #[inline]
-            pub fn dmaudr1(&mut self) -> _DMAUDR1W {
-                _DMAUDR1W { w: self }
-            }
-        }
+}
+impl Deref for GPIOB {
+    type Target = gpiob::RegisterBlock;
+    fn deref(&self) -> &gpiob::RegisterBlock {
+        unsafe { &*GPIOB::ptr() }
     }
 }
-#[doc = "Serial audio interface"]
-pub struct SAI {
+#[doc = "General-purpose I/Os"]
+pub mod gpiob;
+#[doc = "General-purpose I/Os"]
+pub struct GPIOA {
     _marker: PhantomData<*const ()>,
 }
-unsafe impl Send for SAI {}
-impl SAI {
+unsafe impl Send for GPIOA {}
+impl GPIOA {
     #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const sai::RegisterBlock {
-        0x4001_5800 as *const _
+    pub fn ptr() -> *const gpioa::RegisterBlock {
+        1073872896 as *const _
     }
 }
-impl Deref for SAI {
-    type Target = sai::RegisterBlock;
-    fn deref(&self) -> &sai::RegisterBlock {
-        unsafe { &*SAI::ptr() }
+impl Deref for GPIOA {
+    type Target = gpioa::RegisterBlock;
+    fn deref(&self) -> &gpioa::RegisterBlock {
+        unsafe { &*GPIOA::ptr() }
     }
 }
-#[doc = "Serial audio interface"]
-pub mod sai {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        _reserved0: [u8; 4usize],
-        #[doc = "0x04 - AConfiguration register 1"]
-        pub acr1: ACR1,
-        #[doc = "0x08 - AConfiguration register 2"]
-        pub acr2: ACR2,
-        #[doc = "0x0c - AFRCR"]
-        pub afrcr: AFRCR,
-        #[doc = "0x10 - ASlot register"]
-        pub aslotr: ASLOTR,
-        #[doc = "0x14 - AInterrupt mask register2"]
-        pub aim: AIM,
-        #[doc = "0x18 - AStatus register"]
-        pub asr: ASR,
-        #[doc = "0x1c - AClear flag register"]
-        pub aclrfr: ACLRFR,
-        #[doc = "0x20 - AData register"]
-        pub adr: ADR,
-        #[doc = "0x24 - BConfiguration register 1"]
-        pub bcr1: BCR1,
-        #[doc = "0x28 - BConfiguration register 2"]
-        pub bcr2: BCR2,
-        #[doc = "0x2c - BFRCR"]
-        pub bfrcr: BFRCR,
-        #[doc = "0x30 - BSlot register"]
-        pub bslotr: BSLOTR,
-        #[doc = "0x34 - BInterrupt mask register2"]
-        pub bim: BIM,
-        #[doc = "0x38 - BStatus register"]
-        pub bsr: BSR,
-        #[doc = "0x3c - BClear flag register"]
-        pub bclrfr: BCLRFR,
-        #[doc = "0x40 - BData register"]
-        pub bdr: BDR,
-    }
-    #[doc = "BConfiguration register 1"]
-    pub struct BCR1 {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "BConfiguration register 1"]
-    pub mod bcr1 {
-        #[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::BCR1 {
-            #[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 = r" Value of the field"]
-        pub struct MCJDIVR {
-            bits: u8,
-        }
-        impl MCJDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NODIVR {
-            bits: bool,
-        }
-        impl NODIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAENR {
-            bits: bool,
-        }
-        impl DMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SAIBENR {
-            bits: bool,
-        }
-        impl SAIBENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OUTDRIR {
-            bits: bool,
-        }
-        impl OUTDRIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MONOR {
-            bits: bool,
-        }
-        impl MONOR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SYNCENR {
-            bits: u8,
-        }
-        impl SYNCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKSTRR {
-            bits: bool,
-        }
-        impl CKSTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSBFIRSTR {
-            bits: bool,
-        }
-        impl LSBFIRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DSR {
-            bits: u8,
-        }
-        impl DSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PRTCFGR {
-            bits: u8,
-        }
-        impl PRTCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER {
-            bits: u8,
-        }
-        impl MODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCJDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCJDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NODIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NODIVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SAIBENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SAIBENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OUTDRIW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OUTDRIW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MONOW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MONOW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SYNCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SYNCENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKSTRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKSTRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSBFIRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSBFIRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PRTCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRTCFGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 20:23 - Master clock divider"]
-            #[inline]
-            pub fn mcjdiv(&self) -> MCJDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCJDIVR { bits }
-            }
-            #[doc = "Bit 19 - No divider"]
-            #[inline]
-            pub fn nodiv(&self) -> NODIVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NODIVR { bits }
-            }
-            #[doc = "Bit 17 - DMA enable"]
-            #[inline]
-            pub fn dmaen(&self) -> DMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAENR { bits }
-            }
-            #[doc = "Bit 16 - Audio block B enable"]
-            #[inline]
-            pub fn saiben(&self) -> SAIBENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SAIBENR { bits }
-            }
-            #[doc = "Bit 13 - Output drive"]
-            #[inline]
-            pub fn out_dri(&self) -> OUTDRIR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OUTDRIR { bits }
-            }
-            #[doc = "Bit 12 - Mono mode"]
-            #[inline]
-            pub fn mono(&self) -> MONOR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MONOR { bits }
-            }
-            #[doc = "Bits 10:11 - Synchronization enable"]
-            #[inline]
-            pub fn syncen(&self) -> SYNCENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SYNCENR { bits }
-            }
-            #[doc = "Bit 9 - Clock strobing edge"]
-            #[inline]
-            pub fn ckstr(&self) -> CKSTRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKSTRR { bits }
-            }
-            #[doc = "Bit 8 - Least significant bit first"]
-            #[inline]
-            pub fn lsbfirst(&self) -> LSBFIRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSBFIRSTR { bits }
-            }
-            #[doc = "Bits 5:7 - Data size"]
-            #[inline]
-            pub fn ds(&self) -> DSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DSR { bits }
-            }
-            #[doc = "Bits 2:3 - Protocol configuration"]
-            #[inline]
-            pub fn prtcfg(&self) -> PRTCFGR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PRTCFGR { bits }
-            }
-            #[doc = "Bits 0:1 - Audio block mode"]
-            #[inline]
-            pub fn mode(&self) -> MODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x40 }
-            }
-            #[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 20:23 - Master clock divider"]
-            #[inline]
-            pub fn mcjdiv(&mut self) -> _MCJDIVW {
-                _MCJDIVW { w: self }
-            }
-            #[doc = "Bit 19 - No divider"]
-            #[inline]
-            pub fn nodiv(&mut self) -> _NODIVW {
-                _NODIVW { w: self }
-            }
-            #[doc = "Bit 17 - DMA enable"]
-            #[inline]
-            pub fn dmaen(&mut self) -> _DMAENW {
-                _DMAENW { w: self }
-            }
-            #[doc = "Bit 16 - Audio block B enable"]
-            #[inline]
-            pub fn saiben(&mut self) -> _SAIBENW {
-                _SAIBENW { w: self }
-            }
-            #[doc = "Bit 13 - Output drive"]
-            #[inline]
-            pub fn out_dri(&mut self) -> _OUTDRIW {
-                _OUTDRIW { w: self }
-            }
-            #[doc = "Bit 12 - Mono mode"]
-            #[inline]
-            pub fn mono(&mut self) -> _MONOW {
-                _MONOW { w: self }
-            }
-            #[doc = "Bits 10:11 - Synchronization enable"]
-            #[inline]
-            pub fn syncen(&mut self) -> _SYNCENW {
-                _SYNCENW { w: self }
-            }
-            #[doc = "Bit 9 - Clock strobing edge"]
-            #[inline]
-            pub fn ckstr(&mut self) -> _CKSTRW {
-                _CKSTRW { w: self }
-            }
-            #[doc = "Bit 8 - Least significant bit first"]
-            #[inline]
-            pub fn lsbfirst(&mut self) -> _LSBFIRSTW {
-                _LSBFIRSTW { w: self }
-            }
-            #[doc = "Bits 5:7 - Data size"]
-            #[inline]
-            pub fn ds(&mut self) -> _DSW {
-                _DSW { w: self }
-            }
-            #[doc = "Bits 2:3 - Protocol configuration"]
-            #[inline]
-            pub fn prtcfg(&mut self) -> _PRTCFGW {
-                _PRTCFGW { w: self }
-            }
-            #[doc = "Bits 0:1 - Audio block mode"]
-            #[inline]
-            pub fn mode(&mut self) -> _MODEW {
-                _MODEW { w: self }
-            }
-        }
-    }
-    #[doc = "BConfiguration register 2"]
-    pub struct BCR2 {
-        register: VolatileCell<u32>,
+#[doc = "General-purpose I/Os"]
+pub mod gpioa;
+#[doc = "Inter-integrated circuit"]
+pub struct I2C3 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for I2C3 {}
+impl I2C3 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2c3::RegisterBlock {
+        1073765376 as *const _
     }
-    #[doc = "BConfiguration register 2"]
-    pub mod bcr2 {
-        #[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::BCR2 {
-            #[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 = r" Value of the field"]
-        pub struct COMPR {
-            bits: u8,
-        }
-        impl COMPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CPLR {
-            bits: bool,
-        }
-        impl CPLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTECNR {
-            bits: u8,
-        }
-        impl MUTECNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MUTEVALR {
-            bits: bool,
-        }
-        impl MUTEVALR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTER {
-            bits: bool,
-        }
-        impl MUTER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TRISR {
-            bits: bool,
-        }
-        impl TRISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFLUSR {
-            bits: bool,
-        }
-        impl FFLUSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _COMPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COMPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CPLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CPLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTECNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTECNW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x3f;
-                const OFFSET: u8 = 7;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MUTEVALW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEVALW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TRISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFLUSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFLUSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 14:15 - Companding mode"]
-            #[inline]
-            pub fn comp(&self) -> COMPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                COMPR { bits }
-            }
-            #[doc = "Bit 13 - Complement bit"]
-            #[inline]
-            pub fn cpl(&self) -> CPLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CPLR { bits }
-            }
-            #[doc = "Bits 7:12 - Mute counter"]
-            #[inline]
-            pub fn mutecn(&self) -> MUTECNR {
-                let bits = {
-                    const MASK: u8 = 0x3f;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MUTECNR { bits }
-            }
-            #[doc = "Bit 6 - Mute value"]
-            #[inline]
-            pub fn muteval(&self) -> MUTEVALR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTEVALR { bits }
-            }
-            #[doc = "Bit 5 - Mute"]
-            #[inline]
-            pub fn mute(&self) -> MUTER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTER { bits }
-            }
-            #[doc = "Bit 4 - Tristate management on data line"]
-            #[inline]
-            pub fn tris(&self) -> TRISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TRISR { bits }
-            }
-            #[doc = "Bit 3 - FIFO flush"]
-            #[inline]
-            pub fn fflus(&self) -> FFLUSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFLUSR { bits }
-            }
-            #[doc = "Bits 0:2 - FIFO threshold"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        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 14:15 - Companding mode"]
-            #[inline]
-            pub fn comp(&mut self) -> _COMPW {
-                _COMPW { w: self }
-            }
-            #[doc = "Bit 13 - Complement bit"]
-            #[inline]
-            pub fn cpl(&mut self) -> _CPLW {
-                _CPLW { w: self }
-            }
-            #[doc = "Bits 7:12 - Mute counter"]
-            #[inline]
-            pub fn mutecn(&mut self) -> _MUTECNW {
-                _MUTECNW { w: self }
-            }
-            #[doc = "Bit 6 - Mute value"]
-            #[inline]
-            pub fn muteval(&mut self) -> _MUTEVALW {
-                _MUTEVALW { w: self }
-            }
-            #[doc = "Bit 5 - Mute"]
-            #[inline]
-            pub fn mute(&mut self) -> _MUTEW {
-                _MUTEW { w: self }
-            }
-            #[doc = "Bit 4 - Tristate management on data line"]
-            #[inline]
-            pub fn tris(&mut self) -> _TRISW {
-                _TRISW { w: self }
-            }
-            #[doc = "Bit 3 - FIFO flush"]
-            #[inline]
-            pub fn fflus(&mut self) -> _FFLUSW {
-                _FFLUSW { w: self }
-            }
-            #[doc = "Bits 0:2 - FIFO threshold"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
+}
+impl Deref for I2C3 {
+    type Target = i2c3::RegisterBlock;
+    fn deref(&self) -> &i2c3::RegisterBlock {
+        unsafe { &*I2C3::ptr() }
     }
-    #[doc = "BFRCR"]
-    pub struct BFRCR {
-        register: VolatileCell<u32>,
+}
+#[doc = "Inter-integrated circuit"]
+pub mod i2c3;
+#[doc = "I2C2"]
+pub struct I2C2 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for I2C2 {}
+impl I2C2 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2c3::RegisterBlock {
+        1073764352 as *const _
     }
-    #[doc = "BFRCR"]
-    pub mod bfrcr {
-        #[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::BFRCR {
-            #[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 = r" Value of the field"]
-        pub struct FSOFFR {
-            bits: bool,
-        }
-        impl FSOFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSPOLR {
-            bits: bool,
-        }
-        impl FSPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSDEFR {
-            bits: bool,
-        }
-        impl FSDEFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSALLR {
-            bits: u8,
-        }
-        impl FSALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FRLR {
-            bits: u8,
-        }
-        impl FRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FSOFFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSOFFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSDEFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSDEFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSALLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 = "Bit 18 - Frame synchronization offset"]
-            #[inline]
-            pub fn fsoff(&self) -> FSOFFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSOFFR { bits }
-            }
-            #[doc = "Bit 17 - Frame synchronization polarity"]
-            #[inline]
-            pub fn fspol(&self) -> FSPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSPOLR { bits }
-            }
-            #[doc = "Bit 16 - Frame synchronization definition"]
-            #[inline]
-            pub fn fsdef(&self) -> FSDEFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSDEFR { bits }
-            }
-            #[doc = "Bits 8:14 - Frame synchronization active level length"]
-            #[inline]
-            pub fn fsall(&self) -> FSALLR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSALLR { bits }
-            }
-            #[doc = "Bits 0:7 - Frame length"]
-            #[inline]
-            pub fn frl(&self) -> FRLR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FRLR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x07 }
-            }
-            #[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 18 - Frame synchronization offset"]
-            #[inline]
-            pub fn fsoff(&mut self) -> _FSOFFW {
-                _FSOFFW { w: self }
-            }
-            #[doc = "Bit 17 - Frame synchronization polarity"]
-            #[inline]
-            pub fn fspol(&mut self) -> _FSPOLW {
-                _FSPOLW { w: self }
-            }
-            #[doc = "Bit 16 - Frame synchronization definition"]
-            #[inline]
-            pub fn fsdef(&mut self) -> _FSDEFW {
-                _FSDEFW { w: self }
-            }
-            #[doc = "Bits 8:14 - Frame synchronization active level length"]
-            #[inline]
-            pub fn fsall(&mut self) -> _FSALLW {
-                _FSALLW { w: self }
-            }
-            #[doc = "Bits 0:7 - Frame length"]
-            #[inline]
-            pub fn frl(&mut self) -> _FRLW {
-                _FRLW { w: self }
-            }
-        }
+}
+impl Deref for I2C2 {
+    type Target = i2c3::RegisterBlock;
+    fn deref(&self) -> &i2c3::RegisterBlock {
+        unsafe { &*I2C2::ptr() }
     }
-    #[doc = "BSlot register"]
-    pub struct BSLOTR {
-        register: VolatileCell<u32>,
+}
+#[doc = "I2C1"]
+pub struct I2C1 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for I2C1 {}
+impl I2C1 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2c3::RegisterBlock {
+        1073763328 as *const _
     }
-    #[doc = "BSlot register"]
-    pub mod bslotr {
-        #[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::BSLOTR {
-            #[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 = r" Value of the field"]
-        pub struct SLOTENR {
-            bits: u16,
-        }
-        impl SLOTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NBSLOTR {
-            bits: u8,
-        }
-        impl NBSLOTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SLOTSZR {
-            bits: u8,
-        }
-        impl SLOTSZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FBOFFR {
-            bits: u8,
-        }
-        impl FBOFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SLOTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SLOTENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NBSLOTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NBSLOTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SLOTSZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SLOTSZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FBOFFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBOFFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 16:31 - Slot enable"]
-            #[inline]
-            pub fn sloten(&self) -> SLOTENR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                SLOTENR { bits }
-            }
-            #[doc = "Bits 8:11 - Number of slots in an audio frame"]
-            #[inline]
-            pub fn nbslot(&self) -> NBSLOTR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                NBSLOTR { bits }
-            }
-            #[doc = "Bits 6:7 - Slot size"]
-            #[inline]
-            pub fn slotsz(&self) -> SLOTSZR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SLOTSZR { bits }
-            }
-            #[doc = "Bits 0:4 - First bit offset"]
-            #[inline]
-            pub fn fboff(&self) -> FBOFFR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FBOFFR { bits }
-            }
-        }
-        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 16:31 - Slot enable"]
-            #[inline]
-            pub fn sloten(&mut self) -> _SLOTENW {
-                _SLOTENW { w: self }
-            }
-            #[doc = "Bits 8:11 - Number of slots in an audio frame"]
-            #[inline]
-            pub fn nbslot(&mut self) -> _NBSLOTW {
-                _NBSLOTW { w: self }
-            }
-            #[doc = "Bits 6:7 - Slot size"]
-            #[inline]
-            pub fn slotsz(&mut self) -> _SLOTSZW {
-                _SLOTSZW { w: self }
-            }
-            #[doc = "Bits 0:4 - First bit offset"]
-            #[inline]
-            pub fn fboff(&mut self) -> _FBOFFW {
-                _FBOFFW { w: self }
-            }
-        }
+}
+impl Deref for I2C1 {
+    type Target = i2c3::RegisterBlock;
+    fn deref(&self) -> &i2c3::RegisterBlock {
+        unsafe { &*I2C1::ptr() }
     }
-    #[doc = "BInterrupt mask register2"]
-    pub struct BIM {
-        register: VolatileCell<u32>,
+}
+#[doc = "Serial peripheral interface"]
+pub struct I2S2EXT {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for I2S2EXT {}
+impl I2S2EXT {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2s2ext::RegisterBlock {
+        1073755136 as *const _
     }
-    #[doc = "BInterrupt mask register2"]
-    pub mod bim {
-        #[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::BIM {
-            #[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 = r" Value of the field"]
-        pub struct LFSDETIER {
-            bits: bool,
-        }
-        impl LFSDETIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AFSDETIER {
-            bits: bool,
-        }
-        impl AFSDETIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CNRDYIER {
-            bits: bool,
-        }
-        impl CNRDYIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FREQIER {
-            bits: bool,
-        }
-        impl FREQIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WCKCFGR {
-            bits: bool,
-        }
-        impl WCKCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTEDETR {
-            bits: bool,
-        }
-        impl MUTEDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVRUDRIER {
-            bits: bool,
-        }
-        impl OVRUDRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LFSDETIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LFSDETIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AFSDETIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFSDETIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNRDYIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNRDYIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FREQIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FREQIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WCKCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WCKCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTEDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OVRUDRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRUDRIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - Late frame synchronization detection interrupt enable"]
-            #[inline]
-            pub fn lfsdetie(&self) -> LFSDETIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LFSDETIER { bits }
-            }
-            #[doc = "Bit 5 - Anticipated frame synchronization detection interrupt enable"]
-            #[inline]
-            pub fn afsdetie(&self) -> AFSDETIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AFSDETIER { bits }
-            }
-            #[doc = "Bit 4 - Codec not ready interrupt enable"]
-            #[inline]
-            pub fn cnrdyie(&self) -> CNRDYIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CNRDYIER { bits }
-            }
-            #[doc = "Bit 3 - FIFO request interrupt enable"]
-            #[inline]
-            pub fn freqie(&self) -> FREQIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FREQIER { bits }
-            }
-            #[doc = "Bit 2 - Wrong clock configuration interrupt enable"]
-            #[inline]
-            pub fn wckcfg(&self) -> WCKCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WCKCFGR { bits }
-            }
-            #[doc = "Bit 1 - Mute detection interrupt enable"]
-            #[inline]
-            pub fn mutedet(&self) -> MUTEDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTEDETR { bits }
-            }
-            #[doc = "Bit 0 - Overrun/underrun interrupt enable"]
-            #[inline]
-            pub fn ovrudrie(&self) -> OVRUDRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRUDRIER { bits }
-            }
-        }
-        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 6 - Late frame synchronization detection interrupt enable"]
-            #[inline]
-            pub fn lfsdetie(&mut self) -> _LFSDETIEW {
-                _LFSDETIEW { w: self }
-            }
-            #[doc = "Bit 5 - Anticipated frame synchronization detection interrupt enable"]
-            #[inline]
-            pub fn afsdetie(&mut self) -> _AFSDETIEW {
-                _AFSDETIEW { w: self }
-            }
-            #[doc = "Bit 4 - Codec not ready interrupt enable"]
-            #[inline]
-            pub fn cnrdyie(&mut self) -> _CNRDYIEW {
-                _CNRDYIEW { w: self }
-            }
-            #[doc = "Bit 3 - FIFO request interrupt enable"]
-            #[inline]
-            pub fn freqie(&mut self) -> _FREQIEW {
-                _FREQIEW { w: self }
-            }
-            #[doc = "Bit 2 - Wrong clock configuration interrupt enable"]
-            #[inline]
-            pub fn wckcfg(&mut self) -> _WCKCFGW {
-                _WCKCFGW { w: self }
-            }
-            #[doc = "Bit 1 - Mute detection interrupt enable"]
-            #[inline]
-            pub fn mutedet(&mut self) -> _MUTEDETW {
-                _MUTEDETW { w: self }
-            }
-            #[doc = "Bit 0 - Overrun/underrun interrupt enable"]
-            #[inline]
-            pub fn ovrudrie(&mut self) -> _OVRUDRIEW {
-                _OVRUDRIEW { w: self }
-            }
-        }
+}
+impl Deref for I2S2EXT {
+    type Target = i2s2ext::RegisterBlock;
+    fn deref(&self) -> &i2s2ext::RegisterBlock {
+        unsafe { &*I2S2EXT::ptr() }
     }
-    #[doc = "BStatus register"]
-    pub struct BSR {
-        register: VolatileCell<u32>,
+}
+#[doc = "Serial peripheral interface"]
+pub mod i2s2ext;
+#[doc = "I2S3ext"]
+pub struct I2S3EXT {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for I2S3EXT {}
+impl I2S3EXT {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2s2ext::RegisterBlock {
+        1073758208 as *const _
     }
-    #[doc = "BStatus register"]
-    pub mod bsr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::BSR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FLVLR {
-            bits: u8,
-        }
-        impl FLVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct LFSDETR {
-            bits: bool,
-        }
-        impl LFSDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AFSDETR {
-            bits: bool,
-        }
-        impl AFSDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CNRDYR {
-            bits: bool,
-        }
-        impl CNRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FREQR {
-            bits: bool,
-        }
-        impl FREQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WCKCFGR {
-            bits: bool,
-        }
-        impl WCKCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTEDETR {
-            bits: bool,
-        }
-        impl MUTEDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVRUDRR {
-            bits: bool,
-        }
-        impl OVRUDRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:18 - FIFO level threshold"]
-            #[inline]
-            pub fn flvl(&self) -> FLVLR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FLVLR { bits }
-            }
-            #[doc = "Bit 6 - Late frame synchronization detection"]
-            #[inline]
-            pub fn lfsdet(&self) -> LFSDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LFSDETR { bits }
-            }
-            #[doc = "Bit 5 - Anticipated frame synchronization detection"]
-            #[inline]
-            pub fn afsdet(&self) -> AFSDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AFSDETR { bits }
-            }
-            #[doc = "Bit 4 - Codec not ready"]
-            #[inline]
-            pub fn cnrdy(&self) -> CNRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CNRDYR { bits }
-            }
-            #[doc = "Bit 3 - FIFO request"]
-            #[inline]
-            pub fn freq(&self) -> FREQR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FREQR { bits }
-            }
-            #[doc = "Bit 2 - Wrong clock configuration flag"]
-            #[inline]
-            pub fn wckcfg(&self) -> WCKCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WCKCFGR { bits }
-            }
-            #[doc = "Bit 1 - Mute detection"]
-            #[inline]
-            pub fn mutedet(&self) -> MUTEDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTEDETR { bits }
-            }
-            #[doc = "Bit 0 - Overrun / underrun"]
-            #[inline]
-            pub fn ovrudr(&self) -> OVRUDRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRUDRR { bits }
-            }
-        }
+}
+impl Deref for I2S3EXT {
+    type Target = i2s2ext::RegisterBlock;
+    fn deref(&self) -> &i2s2ext::RegisterBlock {
+        unsafe { &*I2S3EXT::ptr() }
     }
-    #[doc = "BClear flag register"]
-    pub struct BCLRFR {
-        register: VolatileCell<u32>,
+}
+#[doc = "SPI1"]
+pub struct SPI1 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SPI1 {}
+impl SPI1 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2s2ext::RegisterBlock {
+        1073819648 as *const _
     }
-    #[doc = "BClear flag register"]
-    pub mod bclrfr {
-        #[doc = r" Value to write to the register"]
-        pub struct W {
-            bits: u32,
-        }
-        impl super::BCLRFR {
-            #[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" Proxy"]
-        pub struct _LFSDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LFSDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAFSDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAFSDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNRDYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNRDYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WCKCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WCKCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTEDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OVRUDRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRUDRW<'a> {
-            #[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
-            }
-        }
-        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 6 - Clear late frame synchronization detection flag"]
-            #[inline]
-            pub fn lfsdet(&mut self) -> _LFSDETW {
-                _LFSDETW { w: self }
-            }
-            #[doc = "Bit 5 - Clear anticipated frame synchronization detection flag"]
-            #[inline]
-            pub fn cafsdet(&mut self) -> _CAFSDETW {
-                _CAFSDETW { w: self }
-            }
-            #[doc = "Bit 4 - Clear codec not ready flag"]
-            #[inline]
-            pub fn cnrdy(&mut self) -> _CNRDYW {
-                _CNRDYW { w: self }
-            }
-            #[doc = "Bit 2 - Clear wrong clock configuration flag"]
-            #[inline]
-            pub fn wckcfg(&mut self) -> _WCKCFGW {
-                _WCKCFGW { w: self }
-            }
-            #[doc = "Bit 1 - Mute detection flag"]
-            #[inline]
-            pub fn mutedet(&mut self) -> _MUTEDETW {
-                _MUTEDETW { w: self }
-            }
-            #[doc = "Bit 0 - Clear overrun / underrun"]
-            #[inline]
-            pub fn ovrudr(&mut self) -> _OVRUDRW {
-                _OVRUDRW { w: self }
-            }
-        }
+}
+impl Deref for SPI1 {
+    type Target = i2s2ext::RegisterBlock;
+    fn deref(&self) -> &i2s2ext::RegisterBlock {
+        unsafe { &*SPI1::ptr() }
     }
-    #[doc = "BData register"]
-    pub struct BDR {
-        register: VolatileCell<u32>,
+}
+#[doc = "SPI2"]
+pub struct SPI2 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SPI2 {}
+impl SPI2 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2s2ext::RegisterBlock {
+        1073756160 as *const _
     }
-    #[doc = "BData register"]
-    pub mod bdr {
-        #[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::BDR {
-            #[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 = r" Value of the field"]
-        pub struct DATAR {
-            bits: u32,
-        }
-        impl DATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Data"]
-            #[inline]
-            pub fn data(&self) -> DATAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                DATAR { bits }
-            }
-        }
-        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 0:31 - Data"]
-            #[inline]
-            pub fn data(&mut self) -> _DATAW {
-                _DATAW { w: self }
-            }
-        }
+}
+impl Deref for SPI2 {
+    type Target = i2s2ext::RegisterBlock;
+    fn deref(&self) -> &i2s2ext::RegisterBlock {
+        unsafe { &*SPI2::ptr() }
     }
-    #[doc = "AConfiguration register 1"]
-    pub struct ACR1 {
-        register: VolatileCell<u32>,
+}
+#[doc = "SPI3"]
+pub struct SPI3 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SPI3 {}
+impl SPI3 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2s2ext::RegisterBlock {
+        1073757184 as *const _
     }
-    #[doc = "AConfiguration register 1"]
-    pub mod acr1 {
-        #[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::ACR1 {
-            #[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 = r" Value of the field"]
-        pub struct MCJDIVR {
-            bits: u8,
-        }
-        impl MCJDIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NODIVR {
-            bits: bool,
-        }
-        impl NODIVR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAENR {
-            bits: bool,
-        }
-        impl DMAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SAIAENR {
-            bits: bool,
-        }
-        impl SAIAENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OUTDRIR {
-            bits: bool,
-        }
-        impl OUTDRIR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MONOR {
-            bits: bool,
-        }
-        impl MONOR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct SYNCENR {
-            bits: u8,
-        }
-        impl SYNCENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CKSTRR {
-            bits: bool,
-        }
-        impl CKSTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct LSBFIRSTR {
-            bits: bool,
-        }
-        impl LSBFIRSTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DSR {
-            bits: u8,
-        }
-        impl DSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct PRTCFGR {
-            bits: u8,
-        }
-        impl PRTCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER {
-            bits: u8,
-        }
-        impl MODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MCJDIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MCJDIVW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 20;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NODIVW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NODIVW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SAIAENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SAIAENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OUTDRIW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OUTDRIW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MONOW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MONOW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _SYNCENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SYNCENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 10;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CKSTRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CKSTRW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _LSBFIRSTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LSBFIRSTW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DSW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _PRTCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _PRTCFGW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 2;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                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 20:23 - Master clock divider"]
-            #[inline]
-            pub fn mcjdiv(&self) -> MCJDIVR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 20;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MCJDIVR { bits }
-            }
-            #[doc = "Bit 19 - No divider"]
-            #[inline]
-            pub fn nodiv(&self) -> NODIVR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 19;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                NODIVR { bits }
-            }
-            #[doc = "Bit 17 - DMA enable"]
-            #[inline]
-            pub fn dmaen(&self) -> DMAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAENR { bits }
-            }
-            #[doc = "Bit 16 - Audio block A enable"]
-            #[inline]
-            pub fn saiaen(&self) -> SAIAENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                SAIAENR { bits }
-            }
-            #[doc = "Bit 13 - Output drive"]
-            #[inline]
-            pub fn out_dri(&self) -> OUTDRIR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OUTDRIR { bits }
-            }
-            #[doc = "Bit 12 - Mono mode"]
-            #[inline]
-            pub fn mono(&self) -> MONOR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MONOR { bits }
-            }
-            #[doc = "Bits 10:11 - Synchronization enable"]
-            #[inline]
-            pub fn syncen(&self) -> SYNCENR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SYNCENR { bits }
-            }
-            #[doc = "Bit 9 - Clock strobing edge"]
-            #[inline]
-            pub fn ckstr(&self) -> CKSTRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CKSTRR { bits }
-            }
-            #[doc = "Bit 8 - Least significant bit first"]
-            #[inline]
-            pub fn lsbfirst(&self) -> LSBFIRSTR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LSBFIRSTR { bits }
-            }
-            #[doc = "Bits 5:7 - Data size"]
-            #[inline]
-            pub fn ds(&self) -> DSR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DSR { bits }
-            }
-            #[doc = "Bits 2:3 - Protocol configuration"]
-            #[inline]
-            pub fn prtcfg(&self) -> PRTCFGR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                PRTCFGR { bits }
-            }
-            #[doc = "Bits 0:1 - Audio block mode"]
-            #[inline]
-            pub fn mode(&self) -> MODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x40 }
-            }
-            #[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 20:23 - Master clock divider"]
-            #[inline]
-            pub fn mcjdiv(&mut self) -> _MCJDIVW {
-                _MCJDIVW { w: self }
-            }
-            #[doc = "Bit 19 - No divider"]
-            #[inline]
-            pub fn nodiv(&mut self) -> _NODIVW {
-                _NODIVW { w: self }
-            }
-            #[doc = "Bit 17 - DMA enable"]
-            #[inline]
-            pub fn dmaen(&mut self) -> _DMAENW {
-                _DMAENW { w: self }
-            }
-            #[doc = "Bit 16 - Audio block A enable"]
-            #[inline]
-            pub fn saiaen(&mut self) -> _SAIAENW {
-                _SAIAENW { w: self }
-            }
-            #[doc = "Bit 13 - Output drive"]
-            #[inline]
-            pub fn out_dri(&mut self) -> _OUTDRIW {
-                _OUTDRIW { w: self }
-            }
-            #[doc = "Bit 12 - Mono mode"]
-            #[inline]
-            pub fn mono(&mut self) -> _MONOW {
-                _MONOW { w: self }
-            }
-            #[doc = "Bits 10:11 - Synchronization enable"]
-            #[inline]
-            pub fn syncen(&mut self) -> _SYNCENW {
-                _SYNCENW { w: self }
-            }
-            #[doc = "Bit 9 - Clock strobing edge"]
-            #[inline]
-            pub fn ckstr(&mut self) -> _CKSTRW {
-                _CKSTRW { w: self }
-            }
-            #[doc = "Bit 8 - Least significant bit first"]
-            #[inline]
-            pub fn lsbfirst(&mut self) -> _LSBFIRSTW {
-                _LSBFIRSTW { w: self }
-            }
-            #[doc = "Bits 5:7 - Data size"]
-            #[inline]
-            pub fn ds(&mut self) -> _DSW {
-                _DSW { w: self }
-            }
-            #[doc = "Bits 2:3 - Protocol configuration"]
-            #[inline]
-            pub fn prtcfg(&mut self) -> _PRTCFGW {
-                _PRTCFGW { w: self }
-            }
-            #[doc = "Bits 0:1 - Audio block mode"]
-            #[inline]
-            pub fn mode(&mut self) -> _MODEW {
-                _MODEW { w: self }
-            }
-        }
+}
+impl Deref for SPI3 {
+    type Target = i2s2ext::RegisterBlock;
+    fn deref(&self) -> &i2s2ext::RegisterBlock {
+        unsafe { &*SPI3::ptr() }
     }
-    #[doc = "AConfiguration register 2"]
-    pub struct ACR2 {
-        register: VolatileCell<u32>,
+}
+#[doc = "SPI4"]
+pub struct SPI4 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SPI4 {}
+impl SPI4 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2s2ext::RegisterBlock {
+        1073820672 as *const _
     }
-    #[doc = "AConfiguration register 2"]
-    pub mod acr2 {
-        #[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::ACR2 {
-            #[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 = r" Value of the field"]
-        pub struct COMPR {
-            bits: u8,
-        }
-        impl COMPR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct CPLR {
-            bits: bool,
-        }
-        impl CPLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTECNR {
-            bits: u8,
-        }
-        impl MUTECNR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MUTEVALR {
-            bits: bool,
-        }
-        impl MUTEVALR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTER {
-            bits: bool,
-        }
-        impl MUTER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct TRISR {
-            bits: bool,
-        }
-        impl TRISR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FFLUSR {
-            bits: bool,
-        }
-        impl FFLUSR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FTHR {
-            bits: u8,
-        }
-        impl FTHR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _COMPW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _COMPW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 14;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _CPLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CPLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTECNW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTECNW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x3f;
-                const OFFSET: u8 = 7;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MUTEVALW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEVALW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _TRISW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _TRISW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FFLUSW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FFLUSW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FTHW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FTHW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                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 14:15 - Companding mode"]
-            #[inline]
-            pub fn comp(&self) -> COMPR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 14;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                COMPR { bits }
-            }
-            #[doc = "Bit 13 - Complement bit"]
-            #[inline]
-            pub fn cpl(&self) -> CPLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 13;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CPLR { bits }
-            }
-            #[doc = "Bits 7:12 - Mute counter"]
-            #[inline]
-            pub fn mutecn(&self) -> MUTECNR {
-                let bits = {
-                    const MASK: u8 = 0x3f;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MUTECNR { bits }
-            }
-            #[doc = "Bit 6 - Mute value"]
-            #[inline]
-            pub fn muteval(&self) -> MUTEVALR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTEVALR { bits }
-            }
-            #[doc = "Bit 5 - Mute"]
-            #[inline]
-            pub fn mute(&self) -> MUTER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTER { bits }
-            }
-            #[doc = "Bit 4 - Tristate management on data line"]
-            #[inline]
-            pub fn tris(&self) -> TRISR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                TRISR { bits }
-            }
-            #[doc = "Bit 3 - FIFO flush"]
-            #[inline]
-            pub fn fflus(&self) -> FFLUSR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FFLUSR { bits }
-            }
-            #[doc = "Bits 0:2 - FIFO threshold"]
-            #[inline]
-            pub fn fth(&self) -> FTHR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FTHR { bits }
-            }
-        }
-        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 14:15 - Companding mode"]
-            #[inline]
-            pub fn comp(&mut self) -> _COMPW {
-                _COMPW { w: self }
-            }
-            #[doc = "Bit 13 - Complement bit"]
-            #[inline]
-            pub fn cpl(&mut self) -> _CPLW {
-                _CPLW { w: self }
-            }
-            #[doc = "Bits 7:12 - Mute counter"]
-            #[inline]
-            pub fn mutecn(&mut self) -> _MUTECNW {
-                _MUTECNW { w: self }
-            }
-            #[doc = "Bit 6 - Mute value"]
-            #[inline]
-            pub fn muteval(&mut self) -> _MUTEVALW {
-                _MUTEVALW { w: self }
-            }
-            #[doc = "Bit 5 - Mute"]
-            #[inline]
-            pub fn mute(&mut self) -> _MUTEW {
-                _MUTEW { w: self }
-            }
-            #[doc = "Bit 4 - Tristate management on data line"]
-            #[inline]
-            pub fn tris(&mut self) -> _TRISW {
-                _TRISW { w: self }
-            }
-            #[doc = "Bit 3 - FIFO flush"]
-            #[inline]
-            pub fn fflus(&mut self) -> _FFLUSW {
-                _FFLUSW { w: self }
-            }
-            #[doc = "Bits 0:2 - FIFO threshold"]
-            #[inline]
-            pub fn fth(&mut self) -> _FTHW {
-                _FTHW { w: self }
-            }
-        }
+}
+impl Deref for SPI4 {
+    type Target = i2s2ext::RegisterBlock;
+    fn deref(&self) -> &i2s2ext::RegisterBlock {
+        unsafe { &*SPI4::ptr() }
+    }
+}
+#[doc = "SPI5"]
+pub struct SPI5 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SPI5 {}
+impl SPI5 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2s2ext::RegisterBlock {
+        1073827840 as *const _
+    }
+}
+impl Deref for SPI5 {
+    type Target = i2s2ext::RegisterBlock;
+    fn deref(&self) -> &i2s2ext::RegisterBlock {
+        unsafe { &*SPI5::ptr() }
+    }
+}
+#[doc = "SPI6"]
+pub struct SPI6 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SPI6 {}
+impl SPI6 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const i2s2ext::RegisterBlock {
+        1073828864 as *const _
+    }
+}
+impl Deref for SPI6 {
+    type Target = i2s2ext::RegisterBlock;
+    fn deref(&self) -> &i2s2ext::RegisterBlock {
+        unsafe { &*SPI6::ptr() }
+    }
+}
+#[doc = "Digital filter for sigma delta modulators"]
+pub struct DFSDM1 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DFSDM1 {}
+impl DFSDM1 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const dfsdm1::RegisterBlock {
+        1073831936 as *const _
+    }
+}
+impl Deref for DFSDM1 {
+    type Target = dfsdm1::RegisterBlock;
+    fn deref(&self) -> &dfsdm1::RegisterBlock {
+        unsafe { &*DFSDM1::ptr() }
+    }
+}
+#[doc = "Digital filter for sigma delta modulators"]
+pub mod dfsdm1;
+#[doc = "DFSDM2"]
+pub struct DFSDM2 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DFSDM2 {}
+impl DFSDM2 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const dfsdm1::RegisterBlock {
+        1073832960 as *const _
+    }
+}
+impl Deref for DFSDM2 {
+    type Target = dfsdm1::RegisterBlock;
+    fn deref(&self) -> &dfsdm1::RegisterBlock {
+        unsafe { &*DFSDM2::ptr() }
+    }
+}
+#[doc = "Basic timers"]
+pub struct TIM6 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM6 {}
+impl TIM6 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim6::RegisterBlock {
+        1073745920 as *const _
+    }
+}
+impl Deref for TIM6 {
+    type Target = tim6::RegisterBlock;
+    fn deref(&self) -> &tim6::RegisterBlock {
+        unsafe { &*TIM6::ptr() }
+    }
+}
+#[doc = "Basic timers"]
+pub mod tim6;
+#[doc = "TIM7"]
+pub struct TIM7 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM7 {}
+impl TIM7 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim6::RegisterBlock {
+        1073746944 as *const _
+    }
+}
+impl Deref for TIM7 {
+    type Target = tim6::RegisterBlock;
+    fn deref(&self) -> &tim6::RegisterBlock {
+        unsafe { &*TIM7::ptr() }
     }
-    #[doc = "AFRCR"]
-    pub struct AFRCR {
-        register: VolatileCell<u32>,
+}
+#[doc = "General purpose timers"]
+pub struct TIM12 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM12 {}
+impl TIM12 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim12::RegisterBlock {
+        1073747968 as *const _
     }
-    #[doc = "AFRCR"]
-    pub mod afrcr {
-        #[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::AFRCR {
-            #[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 = r" Value of the field"]
-        pub struct FSOFFR {
-            bits: bool,
-        }
-        impl FSOFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSPOLR {
-            bits: bool,
-        }
-        impl FSPOLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSDEFR {
-            bits: bool,
-        }
-        impl FSDEFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FSALLR {
-            bits: u8,
-        }
-        impl FSALLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FRLR {
-            bits: u8,
-        }
-        impl FRLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FSOFFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSOFFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSPOLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSPOLW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSDEFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSDEFW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FSALLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FSALLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x7f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FRLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FRLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0xff;
-                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 = "Bit 18 - Frame synchronization offset"]
-            #[inline]
-            pub fn fsoff(&self) -> FSOFFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 18;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSOFFR { bits }
-            }
-            #[doc = "Bit 17 - Frame synchronization polarity"]
-            #[inline]
-            pub fn fspol(&self) -> FSPOLR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 17;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSPOLR { bits }
-            }
-            #[doc = "Bit 16 - Frame synchronization definition"]
-            #[inline]
-            pub fn fsdef(&self) -> FSDEFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FSDEFR { bits }
-            }
-            #[doc = "Bits 8:14 - Frame synchronization active level length"]
-            #[inline]
-            pub fn fsall(&self) -> FSALLR {
-                let bits = {
-                    const MASK: u8 = 0x7f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FSALLR { bits }
-            }
-            #[doc = "Bits 0:7 - Frame length"]
-            #[inline]
-            pub fn frl(&self) -> FRLR {
-                let bits = {
-                    const MASK: u8 = 0xff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FRLR { bits }
-            }
-        }
-        impl W {
-            #[doc = r" Reset value of the register"]
-            #[inline]
-            pub fn reset_value() -> W {
-                W { bits: 0x07 }
-            }
-            #[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 18 - Frame synchronization offset"]
-            #[inline]
-            pub fn fsoff(&mut self) -> _FSOFFW {
-                _FSOFFW { w: self }
-            }
-            #[doc = "Bit 17 - Frame synchronization polarity"]
-            #[inline]
-            pub fn fspol(&mut self) -> _FSPOLW {
-                _FSPOLW { w: self }
-            }
-            #[doc = "Bit 16 - Frame synchronization definition"]
-            #[inline]
-            pub fn fsdef(&mut self) -> _FSDEFW {
-                _FSDEFW { w: self }
-            }
-            #[doc = "Bits 8:14 - Frame synchronization active level length"]
-            #[inline]
-            pub fn fsall(&mut self) -> _FSALLW {
-                _FSALLW { w: self }
-            }
-            #[doc = "Bits 0:7 - Frame length"]
-            #[inline]
-            pub fn frl(&mut self) -> _FRLW {
-                _FRLW { w: self }
-            }
-        }
+}
+impl Deref for TIM12 {
+    type Target = tim12::RegisterBlock;
+    fn deref(&self) -> &tim12::RegisterBlock {
+        unsafe { &*TIM12::ptr() }
     }
-    #[doc = "ASlot register"]
-    pub struct ASLOTR {
-        register: VolatileCell<u32>,
+}
+#[doc = "General purpose timers"]
+pub mod tim12;
+#[doc = "General purpose timers"]
+pub struct TIM13 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM13 {}
+impl TIM13 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim13::RegisterBlock {
+        1073748992 as *const _
     }
-    #[doc = "ASlot register"]
-    pub mod aslotr {
-        #[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::ASLOTR {
-            #[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 = r" Value of the field"]
-        pub struct SLOTENR {
-            bits: u16,
-        }
-        impl SLOTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u16 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct NBSLOTR {
-            bits: u8,
-        }
-        impl NBSLOTR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct SLOTSZR {
-            bits: u8,
-        }
-        impl SLOTSZR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct FBOFFR {
-            bits: u8,
-        }
-        impl FBOFFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SLOTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SLOTENW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u16) -> &'a mut W {
-                const MASK: u16 = 0xffff;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _NBSLOTW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _NBSLOTW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x0f;
-                const OFFSET: u8 = 8;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _SLOTSZW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _SLOTSZW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 6;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _FBOFFW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FBOFFW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x1f;
-                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 16:31 - Slot enable"]
-            #[inline]
-            pub fn sloten(&self) -> SLOTENR {
-                let bits = {
-                    const MASK: u16 = 0xffff;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u16
-                };
-                SLOTENR { bits }
-            }
-            #[doc = "Bits 8:11 - Number of slots in an audio frame"]
-            #[inline]
-            pub fn nbslot(&self) -> NBSLOTR {
-                let bits = {
-                    const MASK: u8 = 0x0f;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                NBSLOTR { bits }
-            }
-            #[doc = "Bits 6:7 - Slot size"]
-            #[inline]
-            pub fn slotsz(&self) -> SLOTSZR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                SLOTSZR { bits }
-            }
-            #[doc = "Bits 0:4 - First bit offset"]
-            #[inline]
-            pub fn fboff(&self) -> FBOFFR {
-                let bits = {
-                    const MASK: u8 = 0x1f;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FBOFFR { bits }
-            }
-        }
-        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 16:31 - Slot enable"]
-            #[inline]
-            pub fn sloten(&mut self) -> _SLOTENW {
-                _SLOTENW { w: self }
-            }
-            #[doc = "Bits 8:11 - Number of slots in an audio frame"]
-            #[inline]
-            pub fn nbslot(&mut self) -> _NBSLOTW {
-                _NBSLOTW { w: self }
-            }
-            #[doc = "Bits 6:7 - Slot size"]
-            #[inline]
-            pub fn slotsz(&mut self) -> _SLOTSZW {
-                _SLOTSZW { w: self }
-            }
-            #[doc = "Bits 0:4 - First bit offset"]
-            #[inline]
-            pub fn fboff(&mut self) -> _FBOFFW {
-                _FBOFFW { w: self }
-            }
-        }
+}
+impl Deref for TIM13 {
+    type Target = tim13::RegisterBlock;
+    fn deref(&self) -> &tim13::RegisterBlock {
+        unsafe { &*TIM13::ptr() }
     }
-    #[doc = "AInterrupt mask register2"]
-    pub struct AIM {
-        register: VolatileCell<u32>,
+}
+#[doc = "General purpose timers"]
+pub mod tim13;
+#[doc = "TIM14"]
+pub struct TIM14 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for TIM14 {}
+impl TIM14 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const tim13::RegisterBlock {
+        1073750016 as *const _
     }
-    #[doc = "AInterrupt mask register2"]
-    pub mod aim {
-        #[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::AIM {
-            #[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 = r" Value of the field"]
-        pub struct LFSDETR {
-            bits: bool,
-        }
-        impl LFSDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AFSDETIER {
-            bits: bool,
-        }
-        impl AFSDETIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CNRDYIER {
-            bits: bool,
-        }
-        impl CNRDYIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FREQIER {
-            bits: bool,
-        }
-        impl FREQIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WCKCFGR {
-            bits: bool,
-        }
-        impl WCKCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTEDETR {
-            bits: bool,
-        }
-        impl MUTEDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVRUDRIER {
-            bits: bool,
-        }
-        impl OVRUDRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LFSDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LFSDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AFSDETIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFSDETIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNRDYIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNRDYIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FREQIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FREQIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WCKCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WCKCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTEDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OVRUDRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRUDRIEW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - Late frame synchronization detection interrupt enable"]
-            #[inline]
-            pub fn lfsdet(&self) -> LFSDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LFSDETR { bits }
-            }
-            #[doc = "Bit 5 - Anticipated frame synchronization detection interrupt enable"]
-            #[inline]
-            pub fn afsdetie(&self) -> AFSDETIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AFSDETIER { bits }
-            }
-            #[doc = "Bit 4 - Codec not ready interrupt enable"]
-            #[inline]
-            pub fn cnrdyie(&self) -> CNRDYIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CNRDYIER { bits }
-            }
-            #[doc = "Bit 3 - FIFO request interrupt enable"]
-            #[inline]
-            pub fn freqie(&self) -> FREQIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FREQIER { bits }
-            }
-            #[doc = "Bit 2 - Wrong clock configuration interrupt enable"]
-            #[inline]
-            pub fn wckcfg(&self) -> WCKCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WCKCFGR { bits }
-            }
-            #[doc = "Bit 1 - Mute detection interrupt enable"]
-            #[inline]
-            pub fn mutedet(&self) -> MUTEDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTEDETR { bits }
-            }
-            #[doc = "Bit 0 - Overrun/underrun interrupt enable"]
-            #[inline]
-            pub fn ovrudrie(&self) -> OVRUDRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRUDRIER { bits }
-            }
-        }
-        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 6 - Late frame synchronization detection interrupt enable"]
-            #[inline]
-            pub fn lfsdet(&mut self) -> _LFSDETW {
-                _LFSDETW { w: self }
-            }
-            #[doc = "Bit 5 - Anticipated frame synchronization detection interrupt enable"]
-            #[inline]
-            pub fn afsdetie(&mut self) -> _AFSDETIEW {
-                _AFSDETIEW { w: self }
-            }
-            #[doc = "Bit 4 - Codec not ready interrupt enable"]
-            #[inline]
-            pub fn cnrdyie(&mut self) -> _CNRDYIEW {
-                _CNRDYIEW { w: self }
-            }
-            #[doc = "Bit 3 - FIFO request interrupt enable"]
-            #[inline]
-            pub fn freqie(&mut self) -> _FREQIEW {
-                _FREQIEW { w: self }
-            }
-            #[doc = "Bit 2 - Wrong clock configuration interrupt enable"]
-            #[inline]
-            pub fn wckcfg(&mut self) -> _WCKCFGW {
-                _WCKCFGW { w: self }
-            }
-            #[doc = "Bit 1 - Mute detection interrupt enable"]
-            #[inline]
-            pub fn mutedet(&mut self) -> _MUTEDETW {
-                _MUTEDETW { w: self }
-            }
-            #[doc = "Bit 0 - Overrun/underrun interrupt enable"]
-            #[inline]
-            pub fn ovrudrie(&mut self) -> _OVRUDRIEW {
-                _OVRUDRIEW { w: self }
-            }
-        }
+}
+impl Deref for TIM14 {
+    type Target = tim13::RegisterBlock;
+    fn deref(&self) -> &tim13::RegisterBlock {
+        unsafe { &*TIM14::ptr() }
+    }
+}
+#[doc = "Random number generator"]
+pub struct RNG {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for RNG {}
+impl RNG {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const rng::RegisterBlock {
+        1342572544 as *const _
     }
-    #[doc = "AStatus register"]
-    pub struct ASR {
-        register: VolatileCell<u32>,
+}
+impl Deref for RNG {
+    type Target = rng::RegisterBlock;
+    fn deref(&self) -> &rng::RegisterBlock {
+        unsafe { &*RNG::ptr() }
     }
-    #[doc = "AStatus register"]
-    pub mod asr {
-        #[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::ASR {
-            #[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 = r" Value of the field"]
-        pub struct FLVLR {
-            bits: u8,
-        }
-        impl FLVLR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct LFSDETR {
-            bits: bool,
-        }
-        impl LFSDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct AFSDETR {
-            bits: bool,
-        }
-        impl AFSDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CNRDYR {
-            bits: bool,
-        }
-        impl CNRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct FREQR {
-            bits: bool,
-        }
-        impl FREQR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WCKCFGR {
-            bits: bool,
-        }
-        impl WCKCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTEDETR {
-            bits: bool,
-        }
-        impl MUTEDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVRUDRR {
-            bits: bool,
-        }
-        impl OVRUDRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _FLVLW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FLVLW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x07;
-                const OFFSET: u8 = 16;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _LFSDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LFSDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _AFSDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AFSDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNRDYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNRDYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _FREQW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _FREQW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WCKCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WCKCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTEDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OVRUDRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRUDRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 16:18 - FIFO level threshold"]
-            #[inline]
-            pub fn flvl(&self) -> FLVLR {
-                let bits = {
-                    const MASK: u8 = 0x07;
-                    const OFFSET: u8 = 16;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                FLVLR { bits }
-            }
-            #[doc = "Bit 6 - Late frame synchronization detection"]
-            #[inline]
-            pub fn lfsdet(&self) -> LFSDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LFSDETR { bits }
-            }
-            #[doc = "Bit 5 - Anticipated frame synchronization detection"]
-            #[inline]
-            pub fn afsdet(&self) -> AFSDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                AFSDETR { bits }
-            }
-            #[doc = "Bit 4 - Codec not ready"]
-            #[inline]
-            pub fn cnrdy(&self) -> CNRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CNRDYR { bits }
-            }
-            #[doc = "Bit 3 - FIFO request"]
-            #[inline]
-            pub fn freq(&self) -> FREQR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                FREQR { bits }
-            }
-            #[doc = "Bit 2 - Wrong clock configuration flag. This bit is read only."]
-            #[inline]
-            pub fn wckcfg(&self) -> WCKCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WCKCFGR { bits }
-            }
-            #[doc = "Bit 1 - Mute detection"]
-            #[inline]
-            pub fn mutedet(&self) -> MUTEDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTEDETR { bits }
-            }
-            #[doc = "Bit 0 - Overrun / underrun"]
-            #[inline]
-            pub fn ovrudr(&self) -> OVRUDRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRUDRR { bits }
-            }
-        }
-        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 16:18 - FIFO level threshold"]
-            #[inline]
-            pub fn flvl(&mut self) -> _FLVLW {
-                _FLVLW { w: self }
-            }
-            #[doc = "Bit 6 - Late frame synchronization detection"]
-            #[inline]
-            pub fn lfsdet(&mut self) -> _LFSDETW {
-                _LFSDETW { w: self }
-            }
-            #[doc = "Bit 5 - Anticipated frame synchronization detection"]
-            #[inline]
-            pub fn afsdet(&mut self) -> _AFSDETW {
-                _AFSDETW { w: self }
-            }
-            #[doc = "Bit 4 - Codec not ready"]
-            #[inline]
-            pub fn cnrdy(&mut self) -> _CNRDYW {
-                _CNRDYW { w: self }
-            }
-            #[doc = "Bit 3 - FIFO request"]
-            #[inline]
-            pub fn freq(&mut self) -> _FREQW {
-                _FREQW { w: self }
-            }
-            #[doc = "Bit 2 - Wrong clock configuration flag. This bit is read only."]
-            #[inline]
-            pub fn wckcfg(&mut self) -> _WCKCFGW {
-                _WCKCFGW { w: self }
-            }
-            #[doc = "Bit 1 - Mute detection"]
-            #[inline]
-            pub fn mutedet(&mut self) -> _MUTEDETW {
-                _MUTEDETW { w: self }
-            }
-            #[doc = "Bit 0 - Overrun / underrun"]
-            #[inline]
-            pub fn ovrudr(&mut self) -> _OVRUDRW {
-                _OVRUDRW { w: self }
-            }
-        }
+}
+#[doc = "Random number generator"]
+pub mod rng;
+#[doc = "Controller area network"]
+pub struct CAN1 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for CAN1 {}
+impl CAN1 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const can1::RegisterBlock {
+        1073767424 as *const _
     }
-    #[doc = "AClear flag register"]
-    pub struct ACLRFR {
-        register: VolatileCell<u32>,
+}
+impl Deref for CAN1 {
+    type Target = can1::RegisterBlock;
+    fn deref(&self) -> &can1::RegisterBlock {
+        unsafe { &*CAN1::ptr() }
     }
-    #[doc = "AClear flag register"]
-    pub mod aclrfr {
-        #[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::ACLRFR {
-            #[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 = r" Value of the field"]
-        pub struct LFSDETR {
-            bits: bool,
-        }
-        impl LFSDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CAFSDETR {
-            bits: bool,
-        }
-        impl CAFSDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CNRDYR {
-            bits: bool,
-        }
-        impl CNRDYR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct WCKCFGR {
-            bits: bool,
-        }
-        impl WCKCFGR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct MUTEDETR {
-            bits: bool,
-        }
-        impl MUTEDETR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct OVRUDRR {
-            bits: bool,
-        }
-        impl OVRUDRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _LFSDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _LFSDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CAFSDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CAFSDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CNRDYW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CNRDYW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _WCKCFGW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _WCKCFGW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _MUTEDETW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MUTEDETW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _OVRUDRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _OVRUDRW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 6 - Clear late frame synchronization detection flag"]
-            #[inline]
-            pub fn lfsdet(&self) -> LFSDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 6;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                LFSDETR { bits }
-            }
-            #[doc = "Bit 5 - Clear anticipated frame synchronization detection flag."]
-            #[inline]
-            pub fn cafsdet(&self) -> CAFSDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CAFSDETR { bits }
-            }
-            #[doc = "Bit 4 - Clear codec not ready flag"]
-            #[inline]
-            pub fn cnrdy(&self) -> CNRDYR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 4;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CNRDYR { bits }
-            }
-            #[doc = "Bit 2 - Clear wrong clock configuration flag"]
-            #[inline]
-            pub fn wckcfg(&self) -> WCKCFGR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WCKCFGR { bits }
-            }
-            #[doc = "Bit 1 - Mute detection flag"]
-            #[inline]
-            pub fn mutedet(&self) -> MUTEDETR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                MUTEDETR { bits }
-            }
-            #[doc = "Bit 0 - Clear overrun / underrun"]
-            #[inline]
-            pub fn ovrudr(&self) -> OVRUDRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                OVRUDRR { bits }
-            }
-        }
-        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 6 - Clear late frame synchronization detection flag"]
-            #[inline]
-            pub fn lfsdet(&mut self) -> _LFSDETW {
-                _LFSDETW { w: self }
-            }
-            #[doc = "Bit 5 - Clear anticipated frame synchronization detection flag."]
-            #[inline]
-            pub fn cafsdet(&mut self) -> _CAFSDETW {
-                _CAFSDETW { w: self }
-            }
-            #[doc = "Bit 4 - Clear codec not ready flag"]
-            #[inline]
-            pub fn cnrdy(&mut self) -> _CNRDYW {
-                _CNRDYW { w: self }
-            }
-            #[doc = "Bit 2 - Clear wrong clock configuration flag"]
-            #[inline]
-            pub fn wckcfg(&mut self) -> _WCKCFGW {
-                _WCKCFGW { w: self }
-            }
-            #[doc = "Bit 1 - Mute detection flag"]
-            #[inline]
-            pub fn mutedet(&mut self) -> _MUTEDETW {
-                _MUTEDETW { w: self }
-            }
-            #[doc = "Bit 0 - Clear overrun / underrun"]
-            #[inline]
-            pub fn ovrudr(&mut self) -> _OVRUDRW {
-                _OVRUDRW { w: self }
-            }
-        }
+}
+#[doc = "Controller area network"]
+pub mod can1;
+#[doc = "CAN2"]
+pub struct CAN2 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for CAN2 {}
+impl CAN2 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const can1::RegisterBlock {
+        1073768448 as *const _
     }
-    #[doc = "AData register"]
-    pub struct ADR {
-        register: VolatileCell<u32>,
+}
+impl Deref for CAN2 {
+    type Target = can1::RegisterBlock;
+    fn deref(&self) -> &can1::RegisterBlock {
+        unsafe { &*CAN2::ptr() }
     }
-    #[doc = "AData register"]
-    pub mod adr {
-        #[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::ADR {
-            #[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 = r" Value of the field"]
-        pub struct DATAR {
-            bits: u32,
-        }
-        impl DATAR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATAW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATAW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Data"]
-            #[inline]
-            pub fn data(&self) -> DATAR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                DATAR { bits }
-            }
-        }
-        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 0:31 - Data"]
-            #[inline]
-            pub fn data(&mut self) -> _DATAW {
-                _DATAW { w: self }
-            }
-        }
+}
+#[doc = "CAN3"]
+pub struct CAN3 {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for CAN3 {}
+impl CAN3 {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const can1::RegisterBlock {
+        1073769472 as *const _
     }
 }
-#[doc = "Advanced encryption standard hardware accelerator"]
-pub struct AES {
+impl Deref for CAN3 {
+    type Target = can1::RegisterBlock;
+    fn deref(&self) -> &can1::RegisterBlock {
+        unsafe { &*CAN3::ptr() }
+    }
+}
+#[doc = "fast-mode Inter-integrated circuit"]
+pub struct FMPI2C {
     _marker: PhantomData<*const ()>,
 }
-unsafe impl Send for AES {}
-impl AES {
+unsafe impl Send for FMPI2C {}
+impl FMPI2C {
     #[doc = r" Returns a pointer to the register block"]
-    pub fn ptr() -> *const aes::RegisterBlock {
-        0x5006_0000 as *const _
+    pub fn ptr() -> *const fmpi2c::RegisterBlock {
+        1073766400 as *const _
     }
 }
-impl Deref for AES {
-    type Target = aes::RegisterBlock;
-    fn deref(&self) -> &aes::RegisterBlock {
-        unsafe { &*AES::ptr() }
+impl Deref for FMPI2C {
+    type Target = fmpi2c::RegisterBlock;
+    fn deref(&self) -> &fmpi2c::RegisterBlock {
+        unsafe { &*FMPI2C::ptr() }
     }
 }
-#[doc = "Advanced encryption standard hardware accelerator"]
-pub mod aes {
-    use vcell::VolatileCell;
-    #[doc = r" Register block"]
-    #[repr(C)]
-    pub struct RegisterBlock {
-        #[doc = "0x00 - control register"]
-        pub cr: CR,
-        #[doc = "0x04 - status register"]
-        pub sr: SR,
-        #[doc = "0x08 - data input register"]
-        pub dinr: DINR,
-        #[doc = "0x0c - data output register"]
-        pub doutr: DOUTR,
-        #[doc = "0x10 - key register 0"]
-        pub keyr0: KEYR0,
-        #[doc = "0x14 - key register 1"]
-        pub keyr1: KEYR1,
-        #[doc = "0x18 - key register 2"]
-        pub keyr2: KEYR2,
-        #[doc = "0x1c - key register 3"]
-        pub keyr3: KEYR3,
-        #[doc = "0x20 - initialization vector register 0"]
-        pub ivr0: IVR0,
-        #[doc = "0x24 - initialization vector register 1"]
-        pub ivr1: IVR1,
-        #[doc = "0x28 - initialization vector register 2"]
-        pub ivr2: IVR2,
-        #[doc = "0x2c - initialization vector register 3"]
-        pub ivr3: IVR3,
-    }
-    #[doc = "control register"]
-    pub struct CR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "control register"]
-    pub mod cr {
-        #[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::CR {
-            #[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 = r" Value of the field"]
-        pub struct DMAOUTENR {
-            bits: bool,
-        }
-        impl DMAOUTENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct DMAINENR {
-            bits: bool,
-        }
-        impl DMAINENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ERRIER {
-            bits: bool,
-        }
-        impl ERRIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCFIER {
-            bits: bool,
-        }
-        impl CCFIER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct ERRCR {
-            bits: bool,
-        }
-        impl ERRCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCFCR {
-            bits: bool,
-        }
-        impl CCFCR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CHMODR {
-            bits: u8,
-        }
-        impl CHMODR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct MODER {
-            bits: u8,
-        }
-        impl MODER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct DATATYPER {
-            bits: u8,
-        }
-        impl DATATYPER {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u8 {
-                self.bits
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct ENR {
-            bits: bool,
-        }
-        impl ENR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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" Proxy"]
-        pub struct _DMAOUTENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAOUTENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _DMAINENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DMAINENW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ERRIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ERRIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CCFIEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCFIEW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _ERRCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ERRCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CCFCW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CCFCW<'a> {
-            #[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 = r" Proxy"]
-        pub struct _CHMODW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _CHMODW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 5;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _MODEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _MODEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 3;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _DATATYPEW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _DATATYPEW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u8) -> &'a mut W {
-                const MASK: u8 = 0x03;
-                const OFFSET: u8 = 1;
-                self.w.bits &= !((MASK as u32) << OFFSET);
-                self.w.bits |= ((value & MASK) as u32) << OFFSET;
-                self.w
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _ENW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _ENW<'a> {
-            #[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
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 12 - Enable DMA management of data output phase"]
-            #[inline]
-            pub fn dmaouten(&self) -> DMAOUTENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 12;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAOUTENR { bits }
-            }
-            #[doc = "Bit 11 - Enable DMA management of data input phase"]
-            #[inline]
-            pub fn dmainen(&self) -> DMAINENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 11;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                DMAINENR { bits }
-            }
-            #[doc = "Bit 10 - Error interrupt enable"]
-            #[inline]
-            pub fn errie(&self) -> ERRIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 10;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ERRIER { bits }
-            }
-            #[doc = "Bit 9 - CCF flag interrupt enable"]
-            #[inline]
-            pub fn ccfie(&self) -> CCFIER {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 9;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCFIER { bits }
-            }
-            #[doc = "Bit 8 - Error clear"]
-            #[inline]
-            pub fn errc(&self) -> ERRCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 8;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ERRCR { bits }
-            }
-            #[doc = "Bit 7 - Computation Complete Flag Clear"]
-            #[inline]
-            pub fn ccfc(&self) -> CCFCR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 7;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCFCR { bits }
-            }
-            #[doc = "Bits 5:6 - AES chaining mode"]
-            #[inline]
-            pub fn chmod(&self) -> CHMODR {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 5;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                CHMODR { bits }
-            }
-            #[doc = "Bits 3:4 - AES operating mode"]
-            #[inline]
-            pub fn mode(&self) -> MODER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 3;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                MODER { bits }
-            }
-            # [ doc = "Bits 1:2 - Data type selection (for data in and data out to/from the cryptographic block)" ] # [ inline ]
-            pub fn datatype(&self) -> DATATYPER {
-                let bits = {
-                    const MASK: u8 = 0x03;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) as u8
-                };
-                DATATYPER { bits }
-            }
-            #[doc = "Bit 0 - AES enable"]
-            #[inline]
-            pub fn en(&self) -> ENR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                ENR { bits }
-            }
-        }
-        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 12 - Enable DMA management of data output phase"]
-            #[inline]
-            pub fn dmaouten(&mut self) -> _DMAOUTENW {
-                _DMAOUTENW { w: self }
-            }
-            #[doc = "Bit 11 - Enable DMA management of data input phase"]
-            #[inline]
-            pub fn dmainen(&mut self) -> _DMAINENW {
-                _DMAINENW { w: self }
-            }
-            #[doc = "Bit 10 - Error interrupt enable"]
-            #[inline]
-            pub fn errie(&mut self) -> _ERRIEW {
-                _ERRIEW { w: self }
-            }
-            #[doc = "Bit 9 - CCF flag interrupt enable"]
-            #[inline]
-            pub fn ccfie(&mut self) -> _CCFIEW {
-                _CCFIEW { w: self }
-            }
-            #[doc = "Bit 8 - Error clear"]
-            #[inline]
-            pub fn errc(&mut self) -> _ERRCW {
-                _ERRCW { w: self }
-            }
-            #[doc = "Bit 7 - Computation Complete Flag Clear"]
-            #[inline]
-            pub fn ccfc(&mut self) -> _CCFCW {
-                _CCFCW { w: self }
-            }
-            #[doc = "Bits 5:6 - AES chaining mode"]
-            #[inline]
-            pub fn chmod(&mut self) -> _CHMODW {
-                _CHMODW { w: self }
-            }
-            #[doc = "Bits 3:4 - AES operating mode"]
-            #[inline]
-            pub fn mode(&mut self) -> _MODEW {
-                _MODEW { w: self }
-            }
-            # [ doc = "Bits 1:2 - Data type selection (for data in and data out to/from the cryptographic block)" ] # [ inline ]
-            pub fn datatype(&mut self) -> _DATATYPEW {
-                _DATATYPEW { w: self }
-            }
-            #[doc = "Bit 0 - AES enable"]
-            #[inline]
-            pub fn en(&mut self) -> _ENW {
-                _ENW { w: self }
-            }
-        }
-    }
-    #[doc = "status register"]
-    pub struct SR {
-        register: VolatileCell<u32>,
-    }
-    #[doc = "status register"]
-    pub mod sr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::SR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct WRERRR {
-            bits: bool,
-        }
-        impl WRERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct RDERRR {
-            bits: bool,
-        }
-        impl RDERRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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"]
-        pub struct CCFR {
-            bits: bool,
-        }
-        impl CCFR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bit(&self) -> bool {
-                self.bits
-            }
-            #[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()
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bit 2 - Write error flag"]
-            #[inline]
-            pub fn wrerr(&self) -> WRERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 2;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                WRERRR { bits }
-            }
-            #[doc = "Bit 1 - Read error flag"]
-            #[inline]
-            pub fn rderr(&self) -> RDERRR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 1;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                RDERRR { bits }
-            }
-            #[doc = "Bit 0 - Computation complete flag"]
-            #[inline]
-            pub fn ccf(&self) -> CCFR {
-                let bits = {
-                    const MASK: bool = true;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) != 0
-                };
-                CCFR { bits }
-            }
-        }
-    }
-    #[doc = "data input register"]
-    pub struct DINR {
-        register: VolatileCell<u32>,
+#[doc = "fast-mode Inter-integrated circuit"]
+pub mod fmpi2c;
+#[doc = "Flexible static memory controller"]
+pub struct FSMC {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for FSMC {}
+impl FSMC {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const fsmc::RegisterBlock {
+        2684354560 as *const _
     }
-    #[doc = "data input register"]
-    pub mod dinr {
-        #[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::DINR {
-            #[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 = r" Value of the field"]
-        pub struct AES_DINRR {
-            bits: u32,
-        }
-        impl AES_DINRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_DINRW<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_DINRW<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Data Input Register"]
-            #[inline]
-            pub fn aes_dinr(&self) -> AES_DINRR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_DINRR { bits }
-            }
-        }
-        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 0:31 - Data Input Register"]
-            #[inline]
-            pub fn aes_dinr(&mut self) -> _AES_DINRW {
-                _AES_DINRW { w: self }
-            }
-        }
+}
+impl Deref for FSMC {
+    type Target = fsmc::RegisterBlock;
+    fn deref(&self) -> &fsmc::RegisterBlock {
+        unsafe { &*FSMC::ptr() }
     }
-    #[doc = "data output register"]
-    pub struct DOUTR {
-        register: VolatileCell<u32>,
+}
+#[doc = "Flexible static memory controller"]
+pub mod fsmc;
+#[doc = "USB on the go full speed"]
+pub struct OTG_FS_GLOBAL {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for OTG_FS_GLOBAL {}
+impl OTG_FS_GLOBAL {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const otg_fs_global::RegisterBlock {
+        1342177280 as *const _
     }
-    #[doc = "data output register"]
-    pub mod doutr {
-        #[doc = r" Value read from the register"]
-        pub struct R {
-            bits: u32,
-        }
-        impl super::DOUTR {
-            #[doc = r" Reads the contents of the register"]
-            #[inline]
-            pub fn read(&self) -> R {
-                R {
-                    bits: self.register.get(),
-                }
-            }
-        }
-        #[doc = r" Value of the field"]
-        pub struct AES_DOUTRR {
-            bits: u32,
-        }
-        impl AES_DOUTRR {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        impl R {
-            #[doc = r" Value of the register as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-            #[doc = "Bits 0:31 - Data output register"]
-            #[inline]
-            pub fn aes_doutr(&self) -> AES_DOUTRR {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_DOUTRR { bits }
-            }
-        }
+}
+impl Deref for OTG_FS_GLOBAL {
+    type Target = otg_fs_global::RegisterBlock;
+    fn deref(&self) -> &otg_fs_global::RegisterBlock {
+        unsafe { &*OTG_FS_GLOBAL::ptr() }
     }
-    #[doc = "key register 0"]
-    pub struct KEYR0 {
-        register: VolatileCell<u32>,
+}
+#[doc = "USB on the go full speed"]
+pub mod otg_fs_global;
+#[doc = "USB on the go full speed"]
+pub struct OTG_FS_HOST {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for OTG_FS_HOST {}
+impl OTG_FS_HOST {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const otg_fs_host::RegisterBlock {
+        1342178304 as *const _
     }
-    #[doc = "key register 0"]
-    pub mod keyr0 {
-        #[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::KEYR0 {
-            #[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 = r" Value of the field"]
-        pub struct AES_KEYR0R {
-            bits: u32,
-        }
-        impl AES_KEYR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_KEYR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_KEYR0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Data Output Register (LSB key [31:0])"]
-            #[inline]
-            pub fn aes_keyr0(&self) -> AES_KEYR0R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_KEYR0R { bits }
-            }
-        }
-        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 0:31 - Data Output Register (LSB key [31:0])"]
-            #[inline]
-            pub fn aes_keyr0(&mut self) -> _AES_KEYR0W {
-                _AES_KEYR0W { w: self }
-            }
-        }
+}
+impl Deref for OTG_FS_HOST {
+    type Target = otg_fs_host::RegisterBlock;
+    fn deref(&self) -> &otg_fs_host::RegisterBlock {
+        unsafe { &*OTG_FS_HOST::ptr() }
     }
-    #[doc = "key register 1"]
-    pub struct KEYR1 {
-        register: VolatileCell<u32>,
+}
+#[doc = "USB on the go full speed"]
+pub mod otg_fs_host;
+#[doc = "USB on the go full speed"]
+pub struct OTG_FS_DEVICE {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for OTG_FS_DEVICE {}
+impl OTG_FS_DEVICE {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const otg_fs_device::RegisterBlock {
+        1342179328 as *const _
     }
-    #[doc = "key register 1"]
-    pub mod keyr1 {
-        #[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::KEYR1 {
-            #[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 = r" Value of the field"]
-        pub struct AES_KEYR1R {
-            bits: u32,
-        }
-        impl AES_KEYR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_KEYR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_KEYR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - AES key register (key [63:32])"]
-            #[inline]
-            pub fn aes_keyr1(&self) -> AES_KEYR1R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_KEYR1R { bits }
-            }
-        }
-        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 0:31 - AES key register (key [63:32])"]
-            #[inline]
-            pub fn aes_keyr1(&mut self) -> _AES_KEYR1W {
-                _AES_KEYR1W { w: self }
-            }
-        }
+}
+impl Deref for OTG_FS_DEVICE {
+    type Target = otg_fs_device::RegisterBlock;
+    fn deref(&self) -> &otg_fs_device::RegisterBlock {
+        unsafe { &*OTG_FS_DEVICE::ptr() }
     }
-    #[doc = "key register 2"]
-    pub struct KEYR2 {
-        register: VolatileCell<u32>,
+}
+#[doc = "USB on the go full speed"]
+pub mod otg_fs_device;
+#[doc = "USB on the go full speed"]
+pub struct OTG_FS_PWRCLK {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for OTG_FS_PWRCLK {}
+impl OTG_FS_PWRCLK {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const otg_fs_pwrclk::RegisterBlock {
+        1342180864 as *const _
     }
-    #[doc = "key register 2"]
-    pub mod keyr2 {
-        #[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::KEYR2 {
-            #[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 = r" Value of the field"]
-        pub struct AES_KEYR2R {
-            bits: u32,
-        }
-        impl AES_KEYR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_KEYR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_KEYR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - AES key register (key [95:64])"]
-            #[inline]
-            pub fn aes_keyr2(&self) -> AES_KEYR2R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_KEYR2R { bits }
-            }
-        }
-        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 0:31 - AES key register (key [95:64])"]
-            #[inline]
-            pub fn aes_keyr2(&mut self) -> _AES_KEYR2W {
-                _AES_KEYR2W { w: self }
-            }
-        }
+}
+impl Deref for OTG_FS_PWRCLK {
+    type Target = otg_fs_pwrclk::RegisterBlock;
+    fn deref(&self) -> &otg_fs_pwrclk::RegisterBlock {
+        unsafe { &*OTG_FS_PWRCLK::ptr() }
     }
-    #[doc = "key register 3"]
-    pub struct KEYR3 {
-        register: VolatileCell<u32>,
+}
+#[doc = "USB on the go full speed"]
+pub mod otg_fs_pwrclk;
+#[doc = "QuadSPI interface"]
+pub struct QUADSPI {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for QUADSPI {}
+impl QUADSPI {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const quadspi::RegisterBlock {
+        2684358656 as *const _
     }
-    #[doc = "key register 3"]
-    pub mod keyr3 {
-        #[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::KEYR3 {
-            #[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 = r" Value of the field"]
-        pub struct AES_KEYR3R {
-            bits: u32,
-        }
-        impl AES_KEYR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_KEYR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_KEYR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - AES key register (MSB key [127:96])"]
-            #[inline]
-            pub fn aes_keyr3(&self) -> AES_KEYR3R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_KEYR3R { bits }
-            }
-        }
-        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 0:31 - AES key register (MSB key [127:96])"]
-            #[inline]
-            pub fn aes_keyr3(&mut self) -> _AES_KEYR3W {
-                _AES_KEYR3W { w: self }
-            }
-        }
+}
+impl Deref for QUADSPI {
+    type Target = quadspi::RegisterBlock;
+    fn deref(&self) -> &quadspi::RegisterBlock {
+        unsafe { &*QUADSPI::ptr() }
     }
-    #[doc = "initialization vector register 0"]
-    pub struct IVR0 {
-        register: VolatileCell<u32>,
+}
+#[doc = "QuadSPI interface"]
+pub mod quadspi;
+#[doc = "Low power timer"]
+pub struct LPTIM {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for LPTIM {}
+impl LPTIM {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const lptim::RegisterBlock {
+        1073751040 as *const _
     }
-    #[doc = "initialization vector register 0"]
-    pub mod ivr0 {
-        #[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::IVR0 {
-            #[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 = r" Value of the field"]
-        pub struct AES_IVR0R {
-            bits: u32,
-        }
-        impl AES_IVR0R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_IVR0W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_IVR0W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - initialization vector register (LSB IVR [31:0])"]
-            #[inline]
-            pub fn aes_ivr0(&self) -> AES_IVR0R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_IVR0R { bits }
-            }
-        }
-        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 0:31 - initialization vector register (LSB IVR [31:0])"]
-            #[inline]
-            pub fn aes_ivr0(&mut self) -> _AES_IVR0W {
-                _AES_IVR0W { w: self }
-            }
-        }
+}
+impl Deref for LPTIM {
+    type Target = lptim::RegisterBlock;
+    fn deref(&self) -> &lptim::RegisterBlock {
+        unsafe { &*LPTIM::ptr() }
     }
-    #[doc = "initialization vector register 1"]
-    pub struct IVR1 {
-        register: VolatileCell<u32>,
+}
+#[doc = "Low power timer"]
+pub mod lptim;
+#[doc = "Digital-to-analog converter"]
+pub struct DAC {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for DAC {}
+impl DAC {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const dac::RegisterBlock {
+        1073771520 as *const _
     }
-    #[doc = "initialization vector register 1"]
-    pub mod ivr1 {
-        #[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::IVR1 {
-            #[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 = r" Value of the field"]
-        pub struct AES_IVR1R {
-            bits: u32,
-        }
-        impl AES_IVR1R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_IVR1W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_IVR1W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Initialization Vector Register (IVR [63:32])"]
-            #[inline]
-            pub fn aes_ivr1(&self) -> AES_IVR1R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_IVR1R { bits }
-            }
-        }
-        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 0:31 - Initialization Vector Register (IVR [63:32])"]
-            #[inline]
-            pub fn aes_ivr1(&mut self) -> _AES_IVR1W {
-                _AES_IVR1W { w: self }
-            }
-        }
+}
+impl Deref for DAC {
+    type Target = dac::RegisterBlock;
+    fn deref(&self) -> &dac::RegisterBlock {
+        unsafe { &*DAC::ptr() }
     }
-    #[doc = "initialization vector register 2"]
-    pub struct IVR2 {
-        register: VolatileCell<u32>,
+}
+#[doc = "Digital-to-analog converter"]
+pub mod dac;
+#[doc = "Serial audio interface"]
+pub struct SAI {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for SAI {}
+impl SAI {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const sai::RegisterBlock {
+        1073829888 as *const _
     }
-    #[doc = "initialization vector register 2"]
-    pub mod ivr2 {
-        #[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::IVR2 {
-            #[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 = r" Value of the field"]
-        pub struct AES_IVR2R {
-            bits: u32,
-        }
-        impl AES_IVR2R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_IVR2W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_IVR2W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Initialization Vector Register (IVR [95:64])"]
-            #[inline]
-            pub fn aes_ivr2(&self) -> AES_IVR2R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_IVR2R { bits }
-            }
-        }
-        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 0:31 - Initialization Vector Register (IVR [95:64])"]
-            #[inline]
-            pub fn aes_ivr2(&mut self) -> _AES_IVR2W {
-                _AES_IVR2W { w: self }
-            }
-        }
+}
+impl Deref for SAI {
+    type Target = sai::RegisterBlock;
+    fn deref(&self) -> &sai::RegisterBlock {
+        unsafe { &*SAI::ptr() }
     }
-    #[doc = "initialization vector register 3"]
-    pub struct IVR3 {
-        register: VolatileCell<u32>,
+}
+#[doc = "Serial audio interface"]
+pub mod sai;
+#[doc = "Advanced encryption standard hardware accelerator"]
+pub struct AES {
+    _marker: PhantomData<*const ()>,
+}
+unsafe impl Send for AES {}
+impl AES {
+    #[doc = r" Returns a pointer to the register block"]
+    pub fn ptr() -> *const aes::RegisterBlock {
+        1342570496 as *const _
     }
-    #[doc = "initialization vector register 3"]
-    pub mod ivr3 {
-        #[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::IVR3 {
-            #[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 = r" Value of the field"]
-        pub struct AES_IVR3R {
-            bits: u32,
-        }
-        impl AES_IVR3R {
-            #[doc = r" Value of the field as raw bits"]
-            #[inline]
-            pub fn bits(&self) -> u32 {
-                self.bits
-            }
-        }
-        #[doc = r" Proxy"]
-        pub struct _AES_IVR3W<'a> {
-            w: &'a mut W,
-        }
-        impl<'a> _AES_IVR3W<'a> {
-            #[doc = r" Writes raw bits to the field"]
-            #[inline]
-            pub unsafe fn bits(self, value: u32) -> &'a mut W {
-                const MASK: u32 = 0xffff_ffff;
-                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 0:31 - Initialization Vector Register (MSB IVR [127:96])"]
-            #[inline]
-            pub fn aes_ivr3(&self) -> AES_IVR3R {
-                let bits = {
-                    const MASK: u32 = 0xffff_ffff;
-                    const OFFSET: u8 = 0;
-                    ((self.bits >> OFFSET) & MASK as u32) as u32
-                };
-                AES_IVR3R { bits }
-            }
-        }
-        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 0:31 - Initialization Vector Register (MSB IVR [127:96])"]
-            #[inline]
-            pub fn aes_ivr3(&mut self) -> _AES_IVR3W {
-                _AES_IVR3W { w: self }
-            }
-        }
+}
+impl Deref for AES {
+    type Target = aes::RegisterBlock;
+    fn deref(&self) -> &aes::RegisterBlock {
+        unsafe { &*AES::ptr() }
     }
 }
+#[doc = "Advanced encryption standard hardware accelerator"]
+pub mod aes;
+// #[allow(private_no_mangle_statics)]
 #[no_mangle]
 static mut DEVICE_PERIPHERALS: bool = false;
 #[doc = r" All the peripherals"]