drone-cortex-m 0.7.0

//! General-purpose I/O.

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
use reg::{gpioa, gpiob, gpioc, gpiod, gpioe};
#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
use reg::{gpiof, gpiog};
#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
use reg::gpioh;
#[cfg(any(feature = "stm32l4x6"))]
use reg::gpioi;
use reg::prelude::*;

/// Generic GPIO pin.
#[allow(missing_docs)]
pub trait GpioPin<T: RegTag>
where
  Self: Sized + 'static,
  Self::Tokens: From<Self>,
{
  /// Generic GPIO pin tokens.
  type Tokens;

  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  type Afr: RegField<T>;
  type Brr: RegField<T>;
  type BsrrBr: RegField<T>;
  type BsrrBs: RegField<T>;
  #[cfg(any(feature = "stm32f100", feature = "stm32f101",
            feature = "stm32f102", feature = "stm32f103",
            feature = "stm32f107"))]
  type CrCnf: RegField<T>;
  #[cfg(any(feature = "stm32f100", feature = "stm32f101",
            feature = "stm32f102", feature = "stm32f103",
            feature = "stm32f107"))]
  type CrMode: RegField<T>;
  type Idr: RegField<T>;
  type Lckr: RegField<T>;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  type Moder: RegField<T>;
  type Odr: RegField<T>;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  type Ospeedr: RegField<T>;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  type Otyper: RegField<T>;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  type Pupdr: RegField<T>;

  /// Creates a new `GpioPin` driver from provided `tokens`.
  fn new(tokens: Self::Tokens) -> Self;

  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn afr(&self) -> &Self::Afr;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn afr_mut(&mut self) -> &mut Self::Afr;
  fn brr(&self) -> &Self::Brr;
  fn brr_mut(&mut self) -> &mut Self::Brr;
  fn bsrr_br(&self) -> &Self::BsrrBr;
  fn bsrr_br_mut(&mut self) -> &mut Self::BsrrBr;
  fn bsrr_bs(&self) -> &Self::BsrrBs;
  fn bsrr_bs_mut(&mut self) -> &mut Self::BsrrBs;
  #[cfg(any(feature = "stm32f100", feature = "stm32f101",
            feature = "stm32f102", feature = "stm32f103",
            feature = "stm32f107"))]
  fn cr_cnf(&self) -> &Self::CrCnf;
  #[cfg(any(feature = "stm32f100", feature = "stm32f101",
            feature = "stm32f102", feature = "stm32f103",
            feature = "stm32f107"))]
  fn cr_cnf_mut(&mut self) -> &mut Self::CrCnf;
  #[cfg(any(feature = "stm32f100", feature = "stm32f101",
            feature = "stm32f102", feature = "stm32f103",
            feature = "stm32f107"))]
  fn cr_mode(&self) -> &Self::CrMode;
  #[cfg(any(feature = "stm32f100", feature = "stm32f101",
            feature = "stm32f102", feature = "stm32f103",
            feature = "stm32f107"))]
  fn cr_mode_mut(&mut self) -> &mut Self::CrMode;
  fn idr(&self) -> &Self::Idr;
  fn idr_mut(&mut self) -> &mut Self::Idr;
  fn lckr(&self) -> &Self::Lckr;
  fn lckr_mut(&mut self) -> &mut Self::Lckr;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn moder(&self) -> &Self::Moder;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn moder_mut(&mut self) -> &mut Self::Moder;
  fn odr(&self) -> &Self::Odr;
  fn odr_mut(&mut self) -> &mut Self::Odr;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn ospeedr(&self) -> &Self::Ospeedr;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn ospeedr_mut(&mut self) -> &mut Self::Ospeedr;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn otyper(&self) -> &Self::Otyper;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn otyper_mut(&mut self) -> &mut Self::Otyper;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn pupdr(&self) -> &Self::Pupdr;
  #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
            feature = "stm32l4x3", feature = "stm32l4x5",
            feature = "stm32l4x6"))]
  fn pupdr_mut(&mut self) -> &mut Self::Pupdr;
}

/// Generic GPIO pin with `ASCR` register.
#[cfg(any(feature = "stm32l4x6"))]
#[allow(missing_docs)]
pub trait GpioAscrPin<T: RegTag>: GpioPin<T> {
  type Ascr: RegField<T>;

  fn ascr(&self) -> &Self::Ascr;
  fn ascr_mut(&mut self) -> &mut Self::Ascr;
}

#[allow(unused_macros)]
macro_rules! gpio_pin {
  (
    $doc:expr,
    $name:ident,
    $name_macro:ident,
    $doc_tokens:expr,
    $name_tokens:ident,
    $gpio:ident,
    $afr_mod:ident,
    $cr_mod:ident,
    $afr_ty:ident,
    $br_ty:ident,
    $bs_ty:ident,
    $cnf_ty:ident,
    $mode_ty:ident,
    $idr_ty:ident,
    $lck_ty:ident,
    $moder_ty:ident,
    $odr_ty:ident,
    $ospeedr_ty:ident,
    $ot_ty:ident,
    $pupdr_ty:ident,
    $gpio_afr_afr:ident,
    $gpio_brr_br:ident,
    $gpio_bsrr_br:ident,
    $gpio_bsrr_bs:ident,
    $gpio_cr_cnf:ident,
    $gpio_cr_mode:ident,
    $gpio_idr_idr:ident,
    $gpio_lckr_lck:ident,
    $gpio_moder_moder:ident,
    $gpio_odr_odr:ident,
    $gpio_ospeedr_ospeedr:ident,
    $gpio_otyper_ot:ident,
    $gpio_pupdr_pupdr:ident,
    $gpio_afr:ident,
    $gpio_ascr:ident,
    $gpio_brr:ident,
    $gpio_bsrr:ident,
    $gpio_cr:ident,
    $gpio_idr:ident,
    $gpio_lckr:ident,
    $gpio_moder:ident,
    $gpio_odr:ident,
    $gpio_ospeedr:ident,
    $gpio_otyper:ident,
    $gpio_pupdr:ident,
    $afr:ident,
    $asc:ident,
    $br:ident,
    $bs:ident,
    $cnf:ident,
    $mode:ident,
    $idr:ident,
    $lck:ident,
    $moder:ident,
    $odr:ident,
    $ospeedr:ident,
    $ot:ident,
    $pupdr:ident,
    ($((
      $asc_ty:ident,
      $gpio_ascr_asc:ident,
    ))*),
  ) => {
    #[doc = $doc]
    pub struct $name<T: RegTag> {
      tokens: $name_tokens<T>,
    }

    #[doc = $doc_tokens]
    #[allow(missing_docs)]
    pub struct $name_tokens<T: RegTag> {
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      pub $gpio_afr_afr: $gpio::$afr_mod::$afr_ty<T>,
      $(
        #[cfg(any(feature = "stm32l4x6"))]
        pub $gpio_ascr_asc: $gpio::ascr::$asc_ty<T>,
      )*
      pub $gpio_brr_br: $gpio::brr::$br_ty<T>,
      pub $gpio_bsrr_br: $gpio::bsrr::$br_ty<T>,
      pub $gpio_bsrr_bs: $gpio::bsrr::$bs_ty<T>,
      #[cfg(any(feature = "stm32f100", feature = "stm32f101",
                feature = "stm32f102", feature = "stm32f103",
                feature = "stm32f107"))]
      pub $gpio_cr_cnf: $gpio::$cr_mod::$cnf_ty<T>,
      #[cfg(any(feature = "stm32f100", feature = "stm32f101",
                feature = "stm32f102", feature = "stm32f103",
                feature = "stm32f107"))]
      pub $gpio_cr_mode: $gpio::$cr_mod::$mode_ty<T>,
      pub $gpio_idr_idr: $gpio::idr::$idr_ty<T>,
      pub $gpio_lckr_lck: $gpio::lckr::$lck_ty<T>,
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      pub $gpio_moder_moder: $gpio::moder::$moder_ty<T>,
      pub $gpio_odr_odr: $gpio::odr::$odr_ty<T>,
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      pub $gpio_ospeedr_ospeedr: $gpio::ospeedr::$ospeedr_ty<T>,
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      pub $gpio_otyper_ot: $gpio::otyper::$ot_ty<T>,
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      pub $gpio_pupdr_pupdr: $gpio::pupdr::$pupdr_ty<T>,
    }

    #[cfg(any(feature = "stm32l4x6"))]
    /// Creates a new `GpioPin` driver from tokens.
    #[macro_export]
    macro_rules! $name_macro {
      ($regs:ident) => {
        $crate::peripherals::gpio::GpioPin::new(
          $crate::peripherals::gpio::$name_tokens {
            $gpio_afr_afr: $regs.$gpio_afr.$afr,
            $(
              $gpio_ascr_asc: $regs.$gpio_ascr.$asc,
            )*
            $gpio_brr_br: $regs.$gpio_brr.$br,
            $gpio_bsrr_br: $regs.$gpio_bsrr.$br,
            $gpio_bsrr_bs: $regs.$gpio_bsrr.$bs,
            $gpio_idr_idr: $regs.$gpio_idr.$idr,
            $gpio_lckr_lck: $regs.$gpio_lckr.$lck,
            $gpio_moder_moder: $regs.$gpio_moder.$moder,
            $gpio_odr_odr: $regs.$gpio_odr.$odr,
            $gpio_ospeedr_ospeedr: $regs.$gpio_ospeedr.$ospeedr,
            $gpio_otyper_ot: $regs.$gpio_otyper.$ot,
            $gpio_pupdr_pupdr: $regs.$gpio_pupdr.$pupdr,
          }
        )
      }
    }

    #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
              feature = "stm32l4x3", feature = "stm32l4x5"))]
    /// Creates a new `GpioPin` driver from tokens.
    #[macro_export]
    macro_rules! $name_macro {
      ($regs:ident) => {
        $crate::peripherals::gpio::GpioPin::new(
          $crate::peripherals::gpio::$name_tokens {
            $gpio_afr_afr: $regs.$gpio_afr.$afr,
            $gpio_brr_br: $regs.$gpio_brr.$br,
            $gpio_bsrr_br: $regs.$gpio_bsrr.$br,
            $gpio_bsrr_bs: $regs.$gpio_bsrr.$bs,
            $gpio_idr_idr: $regs.$gpio_idr.$idr,
            $gpio_lckr_lck: $regs.$gpio_lckr.$lck,
            $gpio_moder_moder: $regs.$gpio_moder.$moder,
            $gpio_odr_odr: $regs.$gpio_odr.$odr,
            $gpio_ospeedr_ospeedr: $regs.$gpio_ospeedr.$ospeedr,
            $gpio_otyper_ot: $regs.$gpio_otyper.$ot,
            $gpio_pupdr_pupdr: $regs.$gpio_pupdr.$pupdr,
          }
        )
      }
    }

    #[cfg(any(feature = "stm32f100", feature = "stm32f101",
              feature = "stm32f102", feature = "stm32f103",
              feature = "stm32f107"))]
    /// Creates a new `GpioPin` driver from tokens.
    #[macro_export]
    macro_rules! $name_macro {
      ($regs:ident) => {
        $crate::peripherals::gpio::GpioPin::new(
          $crate::peripherals::gpio::$name_tokens {
            $gpio_brr_br: $regs.$gpio_brr_br,
            $gpio_bsrr_br: $regs.$gpio_bsrr_br,
            $gpio_bsrr_bs: $regs.$gpio_bsrr_bs,
            $gpio_cr_cnf: $regs.$gpio_cr_cnf,
            $gpio_cr_mode: $regs.$gpio_cr_mode,
            $gpio_idr_idr: $regs.$gpio_idr_idr,
            $gpio_lckr_lck: $regs.$gpio_lckr_lck,
            $gpio_odr_odr: $regs.$gpio_odr_odr,
          }
        )
      }
    }

    impl<T: RegTag> From<$name<T>> for $name_tokens<T> {
      #[inline(always)]
      fn from(gpio_pin: $name<T>) -> Self {
        gpio_pin.tokens
      }
    }

    impl<T: RegTag> GpioPin<T> for $name<T> {
      type Tokens = $name_tokens<T>;
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      type Afr = $gpio::$afr_mod::$afr_ty<T>;
      type Brr = $gpio::brr::$br_ty<T>;
      type BsrrBr = $gpio::bsrr::$br_ty<T>;
      type BsrrBs = $gpio::bsrr::$bs_ty<T>;
      #[cfg(any(feature = "stm32f100", feature = "stm32f101",
                feature = "stm32f102", feature = "stm32f103",
                feature = "stm32f107"))]
      type CrCnf = $gpio::$cr_mod::$cnf_ty<T>;
      #[cfg(any(feature = "stm32f100", feature = "stm32f101",
                feature = "stm32f102", feature = "stm32f103",
                feature = "stm32f107"))]
      type CrMode = $gpio::$cr_mod::$mode_ty<T>;
      type Idr = $gpio::idr::$idr_ty<T>;
      type Lckr = $gpio::lckr::$lck_ty<T>;
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      type Moder = $gpio::moder::$moder_ty<T>;
      type Odr = $gpio::odr::$odr_ty<T>;
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      type Ospeedr = $gpio::ospeedr::$ospeedr_ty<T>;
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      type Otyper = $gpio::otyper::$ot_ty<T>;
      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      type Pupdr = $gpio::pupdr::$pupdr_ty<T>;

      #[inline(always)]
      fn new(tokens: Self::Tokens) -> Self {
        Self { tokens }
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn afr(&self) -> &Self::Afr {
        &self.tokens.$gpio_afr_afr
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn afr_mut(&mut self) -> &mut Self::Afr {
        &mut self.tokens.$gpio_afr_afr
      }

      #[inline(always)]
      fn brr(&self) -> &Self::Brr {
        &self.tokens.$gpio_brr_br
      }

      #[inline(always)]
      fn brr_mut(&mut self) -> &mut Self::Brr {
        &mut self.tokens.$gpio_brr_br
      }

      #[inline(always)]
      fn bsrr_br(&self) -> &Self::BsrrBr {
        &self.tokens.$gpio_bsrr_br
      }

      #[inline(always)]
      fn bsrr_br_mut(&mut self) -> &mut Self::BsrrBr {
        &mut self.tokens.$gpio_bsrr_br
      }

      #[inline(always)]
      fn bsrr_bs(&self) -> &Self::BsrrBs {
        &self.tokens.$gpio_bsrr_bs
      }

      #[inline(always)]
      fn bsrr_bs_mut(&mut self) -> &mut Self::BsrrBs {
        &mut self.tokens.$gpio_bsrr_bs
      }

      #[cfg(any(feature = "stm32f100", feature = "stm32f101",
                feature = "stm32f102", feature = "stm32f103",
                feature = "stm32f107"))]
      #[inline(always)]
      fn cr_cnf(&self) -> &Self::CrCnf {
        &self.tokens.$gpio_cr_cnf
      }

      #[cfg(any(feature = "stm32f100", feature = "stm32f101",
                feature = "stm32f102", feature = "stm32f103",
                feature = "stm32f107"))]
      #[inline(always)]
      fn cr_cnf_mut(&mut self) -> &mut Self::CrCnf {
        &mut self.tokens.$gpio_cr_cnf
      }

      #[cfg(any(feature = "stm32f100", feature = "stm32f101",
                feature = "stm32f102", feature = "stm32f103",
                feature = "stm32f107"))]
      #[inline(always)]
      fn cr_mode(&self) -> &Self::CrMode {
        &self.tokens.$gpio_cr_mode
      }

      #[cfg(any(feature = "stm32f100", feature = "stm32f101",
                feature = "stm32f102", feature = "stm32f103",
                feature = "stm32f107"))]
      #[inline(always)]
      fn cr_mode_mut(&mut self) -> &mut Self::CrMode {
        &mut self.tokens.$gpio_cr_mode
      }

      #[inline(always)]
      fn idr(&self) -> &Self::Idr {
        &self.tokens.$gpio_idr_idr
      }

      #[inline(always)]
      fn idr_mut(&mut self) -> &mut Self::Idr {
        &mut self.tokens.$gpio_idr_idr
      }

      #[inline(always)]
      fn lckr(&self) -> &Self::Lckr {
        &self.tokens.$gpio_lckr_lck
      }

      #[inline(always)]
      fn lckr_mut(&mut self) -> &mut Self::Lckr {
        &mut self.tokens.$gpio_lckr_lck
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn moder(&self) -> &Self::Moder {
        &self.tokens.$gpio_moder_moder
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn moder_mut(&mut self) -> &mut Self::Moder {
        &mut self.tokens.$gpio_moder_moder
      }

      #[inline(always)]
      fn odr(&self) -> &Self::Odr {
        &self.tokens.$gpio_odr_odr
      }

      #[inline(always)]
      fn odr_mut(&mut self) -> &mut Self::Odr {
        &mut self.tokens.$gpio_odr_odr
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn ospeedr(&self) -> &Self::Ospeedr {
        &self.tokens.$gpio_ospeedr_ospeedr
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn ospeedr_mut(&mut self) -> &mut Self::Ospeedr {
        &mut self.tokens.$gpio_ospeedr_ospeedr
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn otyper(&self) -> &Self::Otyper {
        &self.tokens.$gpio_otyper_ot
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn otyper_mut(&mut self) -> &mut Self::Otyper {
        &mut self.tokens.$gpio_otyper_ot
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn pupdr(&self) -> &Self::Pupdr {
        &self.tokens.$gpio_pupdr_pupdr
      }

      #[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
                feature = "stm32l4x3", feature = "stm32l4x5",
                feature = "stm32l4x6"))]
      #[inline(always)]
      fn pupdr_mut(&mut self) -> &mut Self::Pupdr {
        &mut self.tokens.$gpio_pupdr_pupdr
      }
    }

    $(
      #[cfg(any(feature = "stm32l4x6"))]
      impl<T: RegTag> GpioAscrPin<T> for $name<T> {
        type Ascr = $gpio::ascr::$asc_ty<T>;

        #[inline(always)]
        fn ascr(&self) -> &Self::Ascr {
          &self.tokens.$gpio_ascr_asc
        }

        #[inline(always)]
        fn ascr_mut(&mut self) -> &mut Self::Ascr {
          &mut self.tokens.$gpio_ascr_asc
        }
      }
    )*
  }
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 0.",
  Gpioa0,
  peripheral_gpioa_0,
  "GPIO port A pin 0 tokens.",
  Gpioa0Tokens,
  gpioa,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpioa_afrl_afrl0,
  gpioa_brr_br0,
  gpioa_bsrr_br0,
  gpioa_bsrr_bs0,
  gpioa_crl_cnf0,
  gpioa_crl_mode0,
  gpioa_idr_idr0,
  gpioa_lckr_lck0,
  gpioa_moder_moder0,
  gpioa_odr_odr0,
  gpioa_ospeedr_ospeedr0,
  gpioa_otyper_ot0,
  gpioa_pupdr_pupdr0,
  gpioa_afrl,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crl,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  ((
    Asc0,
    gpioa_ascr_asc0,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 1.",
  Gpioa1,
  peripheral_gpioa_1,
  "GPIO port A pin 1 tokens.",
  Gpioa1Tokens,
  gpioa,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpioa_afrl_afrl1,
  gpioa_brr_br1,
  gpioa_bsrr_br1,
  gpioa_bsrr_bs1,
  gpioa_crl_cnf1,
  gpioa_crl_mode1,
  gpioa_idr_idr1,
  gpioa_lckr_lck1,
  gpioa_moder_moder1,
  gpioa_odr_odr1,
  gpioa_ospeedr_ospeedr1,
  gpioa_otyper_ot1,
  gpioa_pupdr_pupdr1,
  gpioa_afrl,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crl,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  ((
    Asc1,
    gpioa_ascr_asc1,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 2.",
  Gpioa2,
  peripheral_gpioa_2,
  "GPIO port A pin 2 tokens.",
  Gpioa2Tokens,
  gpioa,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpioa_afrl_afrl2,
  gpioa_brr_br2,
  gpioa_bsrr_br2,
  gpioa_bsrr_bs2,
  gpioa_crl_cnf2,
  gpioa_crl_mode2,
  gpioa_idr_idr2,
  gpioa_lckr_lck2,
  gpioa_moder_moder2,
  gpioa_odr_odr2,
  gpioa_ospeedr_ospeedr2,
  gpioa_otyper_ot2,
  gpioa_pupdr_pupdr2,
  gpioa_afrl,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crl,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  ((
    Asc2,
    gpioa_ascr_asc2,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 3.",
  Gpioa3,
  peripheral_gpioa_3,
  "GPIO port A pin 3 tokens.",
  Gpioa3Tokens,
  gpioa,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpioa_afrl_afrl3,
  gpioa_brr_br3,
  gpioa_bsrr_br3,
  gpioa_bsrr_bs3,
  gpioa_crl_cnf3,
  gpioa_crl_mode3,
  gpioa_idr_idr3,
  gpioa_lckr_lck3,
  gpioa_moder_moder3,
  gpioa_odr_odr3,
  gpioa_ospeedr_ospeedr3,
  gpioa_otyper_ot3,
  gpioa_pupdr_pupdr3,
  gpioa_afrl,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crl,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  ((
    Asc3,
    gpioa_ascr_asc3,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 4.",
  Gpioa4,
  peripheral_gpioa_4,
  "GPIO port A pin 4 tokens.",
  Gpioa4Tokens,
  gpioa,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpioa_afrl_afrl4,
  gpioa_brr_br4,
  gpioa_bsrr_br4,
  gpioa_bsrr_bs4,
  gpioa_crl_cnf4,
  gpioa_crl_mode4,
  gpioa_idr_idr4,
  gpioa_lckr_lck4,
  gpioa_moder_moder4,
  gpioa_odr_odr4,
  gpioa_ospeedr_ospeedr4,
  gpioa_otyper_ot4,
  gpioa_pupdr_pupdr4,
  gpioa_afrl,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crl,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  ((
    Asc4,
    gpioa_ascr_asc4,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 5.",
  Gpioa5,
  peripheral_gpioa_5,
  "GPIO port A pin 5 tokens.",
  Gpioa5Tokens,
  gpioa,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpioa_afrl_afrl5,
  gpioa_brr_br5,
  gpioa_bsrr_br5,
  gpioa_bsrr_bs5,
  gpioa_crl_cnf5,
  gpioa_crl_mode5,
  gpioa_idr_idr5,
  gpioa_lckr_lck5,
  gpioa_moder_moder5,
  gpioa_odr_odr5,
  gpioa_ospeedr_ospeedr5,
  gpioa_otyper_ot5,
  gpioa_pupdr_pupdr5,
  gpioa_afrl,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crl,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  ((
    Asc5,
    gpioa_ascr_asc5,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 6.",
  Gpioa6,
  peripheral_gpioa_6,
  "GPIO port A pin 6 tokens.",
  Gpioa6Tokens,
  gpioa,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpioa_afrl_afrl6,
  gpioa_brr_br6,
  gpioa_bsrr_br6,
  gpioa_bsrr_bs6,
  gpioa_crl_cnf6,
  gpioa_crl_mode6,
  gpioa_idr_idr6,
  gpioa_lckr_lck6,
  gpioa_moder_moder6,
  gpioa_odr_odr6,
  gpioa_ospeedr_ospeedr6,
  gpioa_otyper_ot6,
  gpioa_pupdr_pupdr6,
  gpioa_afrl,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crl,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  ((
    Asc6,
    gpioa_ascr_asc6,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 7.",
  Gpioa7,
  peripheral_gpioa_7,
  "GPIO port A pin 7 tokens.",
  Gpioa7Tokens,
  gpioa,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpioa_afrl_afrl7,
  gpioa_brr_br7,
  gpioa_bsrr_br7,
  gpioa_bsrr_bs7,
  gpioa_crl_cnf7,
  gpioa_crl_mode7,
  gpioa_idr_idr7,
  gpioa_lckr_lck7,
  gpioa_moder_moder7,
  gpioa_odr_odr7,
  gpioa_ospeedr_ospeedr7,
  gpioa_otyper_ot7,
  gpioa_pupdr_pupdr7,
  gpioa_afrl,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crl,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  ((
    Asc7,
    gpioa_ascr_asc7,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 8.",
  Gpioa8,
  peripheral_gpioa_8,
  "GPIO port A pin 8 tokens.",
  Gpioa8Tokens,
  gpioa,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpioa_afrh_afrh8,
  gpioa_brr_br8,
  gpioa_bsrr_br8,
  gpioa_bsrr_bs8,
  gpioa_crh_cnf8,
  gpioa_crh_mode8,
  gpioa_idr_idr8,
  gpioa_lckr_lck8,
  gpioa_moder_moder8,
  gpioa_odr_odr8,
  gpioa_ospeedr_ospeedr8,
  gpioa_otyper_ot8,
  gpioa_pupdr_pupdr8,
  gpioa_afrh,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crh,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  ((
    Asc8,
    gpioa_ascr_asc8,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 9.",
  Gpioa9,
  peripheral_gpioa_9,
  "GPIO port A pin 9 tokens.",
  Gpioa9Tokens,
  gpioa,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpioa_afrh_afrh9,
  gpioa_brr_br9,
  gpioa_bsrr_br9,
  gpioa_bsrr_bs9,
  gpioa_crh_cnf9,
  gpioa_crh_mode9,
  gpioa_idr_idr9,
  gpioa_lckr_lck9,
  gpioa_moder_moder9,
  gpioa_odr_odr9,
  gpioa_ospeedr_ospeedr9,
  gpioa_otyper_ot9,
  gpioa_pupdr_pupdr9,
  gpioa_afrh,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crh,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  ((
    Asc9,
    gpioa_ascr_asc9,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 10.",
  Gpioa10,
  peripheral_gpioa_10,
  "GPIO port A pin 10 tokens.",
  Gpioa10Tokens,
  gpioa,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpioa_afrh_afrh10,
  gpioa_brr_br10,
  gpioa_bsrr_br10,
  gpioa_bsrr_bs10,
  gpioa_crh_cnf10,
  gpioa_crh_mode10,
  gpioa_idr_idr10,
  gpioa_lckr_lck10,
  gpioa_moder_moder10,
  gpioa_odr_odr10,
  gpioa_ospeedr_ospeedr10,
  gpioa_otyper_ot10,
  gpioa_pupdr_pupdr10,
  gpioa_afrh,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crh,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  ((
    Asc10,
    gpioa_ascr_asc10,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 11.",
  Gpioa11,
  peripheral_gpioa_11,
  "GPIO port A pin 11 tokens.",
  Gpioa11Tokens,
  gpioa,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpioa_afrh_afrh11,
  gpioa_brr_br11,
  gpioa_bsrr_br11,
  gpioa_bsrr_bs11,
  gpioa_crh_cnf11,
  gpioa_crh_mode11,
  gpioa_idr_idr11,
  gpioa_lckr_lck11,
  gpioa_moder_moder11,
  gpioa_odr_odr11,
  gpioa_ospeedr_ospeedr11,
  gpioa_otyper_ot11,
  gpioa_pupdr_pupdr11,
  gpioa_afrh,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crh,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  ((
    Asc11,
    gpioa_ascr_asc11,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 12.",
  Gpioa12,
  peripheral_gpioa_12,
  "GPIO port A pin 12 tokens.",
  Gpioa12Tokens,
  gpioa,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpioa_afrh_afrh12,
  gpioa_brr_br12,
  gpioa_bsrr_br12,
  gpioa_bsrr_bs12,
  gpioa_crh_cnf12,
  gpioa_crh_mode12,
  gpioa_idr_idr12,
  gpioa_lckr_lck12,
  gpioa_moder_moder12,
  gpioa_odr_odr12,
  gpioa_ospeedr_ospeedr12,
  gpioa_otyper_ot12,
  gpioa_pupdr_pupdr12,
  gpioa_afrh,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crh,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  ((
    Asc12,
    gpioa_ascr_asc12,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 13.",
  Gpioa13,
  peripheral_gpioa_13,
  "GPIO port A pin 13 tokens.",
  Gpioa13Tokens,
  gpioa,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpioa_afrh_afrh13,
  gpioa_brr_br13,
  gpioa_bsrr_br13,
  gpioa_bsrr_bs13,
  gpioa_crh_cnf13,
  gpioa_crh_mode13,
  gpioa_idr_idr13,
  gpioa_lckr_lck13,
  gpioa_moder_moder13,
  gpioa_odr_odr13,
  gpioa_ospeedr_ospeedr13,
  gpioa_otyper_ot13,
  gpioa_pupdr_pupdr13,
  gpioa_afrh,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crh,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  ((
    Asc13,
    gpioa_ascr_asc13,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 14.",
  Gpioa14,
  peripheral_gpioa_14,
  "GPIO port A pin 14 tokens.",
  Gpioa14Tokens,
  gpioa,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpioa_afrh_afrh14,
  gpioa_brr_br14,
  gpioa_bsrr_br14,
  gpioa_bsrr_bs14,
  gpioa_crh_cnf14,
  gpioa_crh_mode14,
  gpioa_idr_idr14,
  gpioa_lckr_lck14,
  gpioa_moder_moder14,
  gpioa_odr_odr14,
  gpioa_ospeedr_ospeedr14,
  gpioa_otyper_ot14,
  gpioa_pupdr_pupdr14,
  gpioa_afrh,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crh,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  ((
    Asc14,
    gpioa_ascr_asc14,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port A pin 15.",
  Gpioa15,
  peripheral_gpioa_15,
  "GPIO port A pin 15 tokens.",
  Gpioa15Tokens,
  gpioa,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpioa_afrh_afrh15,
  gpioa_brr_br15,
  gpioa_bsrr_br15,
  gpioa_bsrr_bs15,
  gpioa_crh_cnf15,
  gpioa_crh_mode15,
  gpioa_idr_idr15,
  gpioa_lckr_lck15,
  gpioa_moder_moder15,
  gpioa_odr_odr15,
  gpioa_ospeedr_ospeedr15,
  gpioa_otyper_ot15,
  gpioa_pupdr_pupdr15,
  gpioa_afrh,
  gpioa_ascr,
  gpioa_brr,
  gpioa_bsrr,
  gpioa_crh,
  gpioa_idr,
  gpioa_lckr,
  gpioa_moder,
  gpioa_odr,
  gpioa_ospeedr,
  gpioa_otyper,
  gpioa_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  ((
    Asc15,
    gpioa_ascr_asc15,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 0.",
  Gpiob0,
  peripheral_gpiob_0,
  "GPIO port B pin 0 tokens.",
  Gpiob0Tokens,
  gpiob,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpiob_afrl_afrl0,
  gpiob_brr_br0,
  gpiob_bsrr_br0,
  gpiob_bsrr_bs0,
  gpiob_crl_cnf0,
  gpiob_crl_mode0,
  gpiob_idr_idr0,
  gpiob_lckr_lck0,
  gpiob_moder_moder0,
  gpiob_odr_odr0,
  gpiob_ospeedr_ospeedr0,
  gpiob_otyper_ot0,
  gpiob_pupdr_pupdr0,
  gpiob_afrl,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crl,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  ((
    Asc0,
    gpiob_ascr_asc0,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 1.",
  Gpiob1,
  peripheral_gpiob_1,
  "GPIO port B pin 1 tokens.",
  Gpiob1Tokens,
  gpiob,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpiob_afrl_afrl1,
  gpiob_brr_br1,
  gpiob_bsrr_br1,
  gpiob_bsrr_bs1,
  gpiob_crl_cnf1,
  gpiob_crl_mode1,
  gpiob_idr_idr1,
  gpiob_lckr_lck1,
  gpiob_moder_moder1,
  gpiob_odr_odr1,
  gpiob_ospeedr_ospeedr1,
  gpiob_otyper_ot1,
  gpiob_pupdr_pupdr1,
  gpiob_afrl,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crl,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  ((
    Asc1,
    gpiob_ascr_asc1,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 2.",
  Gpiob2,
  peripheral_gpiob_2,
  "GPIO port B pin 2 tokens.",
  Gpiob2Tokens,
  gpiob,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpiob_afrl_afrl2,
  gpiob_brr_br2,
  gpiob_bsrr_br2,
  gpiob_bsrr_bs2,
  gpiob_crl_cnf2,
  gpiob_crl_mode2,
  gpiob_idr_idr2,
  gpiob_lckr_lck2,
  gpiob_moder_moder2,
  gpiob_odr_odr2,
  gpiob_ospeedr_ospeedr2,
  gpiob_otyper_ot2,
  gpiob_pupdr_pupdr2,
  gpiob_afrl,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crl,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  ((
    Asc2,
    gpiob_ascr_asc2,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 3.",
  Gpiob3,
  peripheral_gpiob_3,
  "GPIO port B pin 3 tokens.",
  Gpiob3Tokens,
  gpiob,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpiob_afrl_afrl3,
  gpiob_brr_br3,
  gpiob_bsrr_br3,
  gpiob_bsrr_bs3,
  gpiob_crl_cnf3,
  gpiob_crl_mode3,
  gpiob_idr_idr3,
  gpiob_lckr_lck3,
  gpiob_moder_moder3,
  gpiob_odr_odr3,
  gpiob_ospeedr_ospeedr3,
  gpiob_otyper_ot3,
  gpiob_pupdr_pupdr3,
  gpiob_afrl,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crl,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  ((
    Asc3,
    gpiob_ascr_asc3,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 4.",
  Gpiob4,
  peripheral_gpiob_4,
  "GPIO port B pin 4 tokens.",
  Gpiob4Tokens,
  gpiob,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpiob_afrl_afrl4,
  gpiob_brr_br4,
  gpiob_bsrr_br4,
  gpiob_bsrr_bs4,
  gpiob_crl_cnf4,
  gpiob_crl_mode4,
  gpiob_idr_idr4,
  gpiob_lckr_lck4,
  gpiob_moder_moder4,
  gpiob_odr_odr4,
  gpiob_ospeedr_ospeedr4,
  gpiob_otyper_ot4,
  gpiob_pupdr_pupdr4,
  gpiob_afrl,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crl,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  ((
    Asc4,
    gpiob_ascr_asc4,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 5.",
  Gpiob5,
  peripheral_gpiob_5,
  "GPIO port B pin 5 tokens.",
  Gpiob5Tokens,
  gpiob,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpiob_afrl_afrl5,
  gpiob_brr_br5,
  gpiob_bsrr_br5,
  gpiob_bsrr_bs5,
  gpiob_crl_cnf5,
  gpiob_crl_mode5,
  gpiob_idr_idr5,
  gpiob_lckr_lck5,
  gpiob_moder_moder5,
  gpiob_odr_odr5,
  gpiob_ospeedr_ospeedr5,
  gpiob_otyper_ot5,
  gpiob_pupdr_pupdr5,
  gpiob_afrl,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crl,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  ((
    Asc5,
    gpiob_ascr_asc5,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 6.",
  Gpiob6,
  peripheral_gpiob_6,
  "GPIO port B pin 6 tokens.",
  Gpiob6Tokens,
  gpiob,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpiob_afrl_afrl6,
  gpiob_brr_br6,
  gpiob_bsrr_br6,
  gpiob_bsrr_bs6,
  gpiob_crl_cnf6,
  gpiob_crl_mode6,
  gpiob_idr_idr6,
  gpiob_lckr_lck6,
  gpiob_moder_moder6,
  gpiob_odr_odr6,
  gpiob_ospeedr_ospeedr6,
  gpiob_otyper_ot6,
  gpiob_pupdr_pupdr6,
  gpiob_afrl,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crl,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  ((
    Asc6,
    gpiob_ascr_asc6,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 7.",
  Gpiob7,
  peripheral_gpiob_7,
  "GPIO port B pin 7 tokens.",
  Gpiob7Tokens,
  gpiob,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpiob_afrl_afrl7,
  gpiob_brr_br7,
  gpiob_bsrr_br7,
  gpiob_bsrr_bs7,
  gpiob_crl_cnf7,
  gpiob_crl_mode7,
  gpiob_idr_idr7,
  gpiob_lckr_lck7,
  gpiob_moder_moder7,
  gpiob_odr_odr7,
  gpiob_ospeedr_ospeedr7,
  gpiob_otyper_ot7,
  gpiob_pupdr_pupdr7,
  gpiob_afrl,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crl,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  ((
    Asc7,
    gpiob_ascr_asc7,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 8.",
  Gpiob8,
  peripheral_gpiob_8,
  "GPIO port B pin 8 tokens.",
  Gpiob8Tokens,
  gpiob,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpiob_afrh_afrh8,
  gpiob_brr_br8,
  gpiob_bsrr_br8,
  gpiob_bsrr_bs8,
  gpiob_crh_cnf8,
  gpiob_crh_mode8,
  gpiob_idr_idr8,
  gpiob_lckr_lck8,
  gpiob_moder_moder8,
  gpiob_odr_odr8,
  gpiob_ospeedr_ospeedr8,
  gpiob_otyper_ot8,
  gpiob_pupdr_pupdr8,
  gpiob_afrh,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crh,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  ((
    Asc8,
    gpiob_ascr_asc8,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 9.",
  Gpiob9,
  peripheral_gpiob_9,
  "GPIO port B pin 9 tokens.",
  Gpiob9Tokens,
  gpiob,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpiob_afrh_afrh9,
  gpiob_brr_br9,
  gpiob_bsrr_br9,
  gpiob_bsrr_bs9,
  gpiob_crh_cnf9,
  gpiob_crh_mode9,
  gpiob_idr_idr9,
  gpiob_lckr_lck9,
  gpiob_moder_moder9,
  gpiob_odr_odr9,
  gpiob_ospeedr_ospeedr9,
  gpiob_otyper_ot9,
  gpiob_pupdr_pupdr9,
  gpiob_afrh,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crh,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  ((
    Asc9,
    gpiob_ascr_asc9,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 10.",
  Gpiob10,
  peripheral_gpiob_10,
  "GPIO port B pin 10 tokens.",
  Gpiob10Tokens,
  gpiob,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpiob_afrh_afrh10,
  gpiob_brr_br10,
  gpiob_bsrr_br10,
  gpiob_bsrr_bs10,
  gpiob_crh_cnf10,
  gpiob_crh_mode10,
  gpiob_idr_idr10,
  gpiob_lckr_lck10,
  gpiob_moder_moder10,
  gpiob_odr_odr10,
  gpiob_ospeedr_ospeedr10,
  gpiob_otyper_ot10,
  gpiob_pupdr_pupdr10,
  gpiob_afrh,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crh,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  ((
    Asc10,
    gpiob_ascr_asc10,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 11.",
  Gpiob11,
  peripheral_gpiob_11,
  "GPIO port B pin 11 tokens.",
  Gpiob11Tokens,
  gpiob,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpiob_afrh_afrh11,
  gpiob_brr_br11,
  gpiob_bsrr_br11,
  gpiob_bsrr_bs11,
  gpiob_crh_cnf11,
  gpiob_crh_mode11,
  gpiob_idr_idr11,
  gpiob_lckr_lck11,
  gpiob_moder_moder11,
  gpiob_odr_odr11,
  gpiob_ospeedr_ospeedr11,
  gpiob_otyper_ot11,
  gpiob_pupdr_pupdr11,
  gpiob_afrh,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crh,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  ((
    Asc11,
    gpiob_ascr_asc11,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 12.",
  Gpiob12,
  peripheral_gpiob_12,
  "GPIO port B pin 12 tokens.",
  Gpiob12Tokens,
  gpiob,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpiob_afrh_afrh12,
  gpiob_brr_br12,
  gpiob_bsrr_br12,
  gpiob_bsrr_bs12,
  gpiob_crh_cnf12,
  gpiob_crh_mode12,
  gpiob_idr_idr12,
  gpiob_lckr_lck12,
  gpiob_moder_moder12,
  gpiob_odr_odr12,
  gpiob_ospeedr_ospeedr12,
  gpiob_otyper_ot12,
  gpiob_pupdr_pupdr12,
  gpiob_afrh,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crh,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  ((
    Asc12,
    gpiob_ascr_asc12,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 13.",
  Gpiob13,
  peripheral_gpiob_13,
  "GPIO port B pin 13 tokens.",
  Gpiob13Tokens,
  gpiob,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpiob_afrh_afrh13,
  gpiob_brr_br13,
  gpiob_bsrr_br13,
  gpiob_bsrr_bs13,
  gpiob_crh_cnf13,
  gpiob_crh_mode13,
  gpiob_idr_idr13,
  gpiob_lckr_lck13,
  gpiob_moder_moder13,
  gpiob_odr_odr13,
  gpiob_ospeedr_ospeedr13,
  gpiob_otyper_ot13,
  gpiob_pupdr_pupdr13,
  gpiob_afrh,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crh,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  ((
    Asc13,
    gpiob_ascr_asc13,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 14.",
  Gpiob14,
  peripheral_gpiob_14,
  "GPIO port B pin 14 tokens.",
  Gpiob14Tokens,
  gpiob,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpiob_afrh_afrh14,
  gpiob_brr_br14,
  gpiob_bsrr_br14,
  gpiob_bsrr_bs14,
  gpiob_crh_cnf14,
  gpiob_crh_mode14,
  gpiob_idr_idr14,
  gpiob_lckr_lck14,
  gpiob_moder_moder14,
  gpiob_odr_odr14,
  gpiob_ospeedr_ospeedr14,
  gpiob_otyper_ot14,
  gpiob_pupdr_pupdr14,
  gpiob_afrh,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crh,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  ((
    Asc14,
    gpiob_ascr_asc14,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port B pin 15.",
  Gpiob15,
  peripheral_gpiob_15,
  "GPIO port B pin 15 tokens.",
  Gpiob15Tokens,
  gpiob,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpiob_afrh_afrh15,
  gpiob_brr_br15,
  gpiob_bsrr_br15,
  gpiob_bsrr_bs15,
  gpiob_crh_cnf15,
  gpiob_crh_mode15,
  gpiob_idr_idr15,
  gpiob_lckr_lck15,
  gpiob_moder_moder15,
  gpiob_odr_odr15,
  gpiob_ospeedr_ospeedr15,
  gpiob_otyper_ot15,
  gpiob_pupdr_pupdr15,
  gpiob_afrh,
  gpiob_ascr,
  gpiob_brr,
  gpiob_bsrr,
  gpiob_crh,
  gpiob_idr,
  gpiob_lckr,
  gpiob_moder,
  gpiob_odr,
  gpiob_ospeedr,
  gpiob_otyper,
  gpiob_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  ((
    Asc15,
    gpiob_ascr_asc15,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 0.",
  Gpioc0,
  peripheral_gpioc_0,
  "GPIO port C pin 0 tokens.",
  Gpioc0Tokens,
  gpioc,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpioc_afrl_afrl0,
  gpioc_brr_br0,
  gpioc_bsrr_br0,
  gpioc_bsrr_bs0,
  gpioc_crl_cnf0,
  gpioc_crl_mode0,
  gpioc_idr_idr0,
  gpioc_lckr_lck0,
  gpioc_moder_moder0,
  gpioc_odr_odr0,
  gpioc_ospeedr_ospeedr0,
  gpioc_otyper_ot0,
  gpioc_pupdr_pupdr0,
  gpioc_afrl,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crl,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  ((
    Asc0,
    gpioc_ascr_asc0,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 1.",
  Gpioc1,
  peripheral_gpioc_1,
  "GPIO port C pin 1 tokens.",
  Gpioc1Tokens,
  gpioc,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpioc_afrl_afrl1,
  gpioc_brr_br1,
  gpioc_bsrr_br1,
  gpioc_bsrr_bs1,
  gpioc_crl_cnf1,
  gpioc_crl_mode1,
  gpioc_idr_idr1,
  gpioc_lckr_lck1,
  gpioc_moder_moder1,
  gpioc_odr_odr1,
  gpioc_ospeedr_ospeedr1,
  gpioc_otyper_ot1,
  gpioc_pupdr_pupdr1,
  gpioc_afrl,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crl,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  ((
    Asc1,
    gpioc_ascr_asc1,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 2.",
  Gpioc2,
  peripheral_gpioc_2,
  "GPIO port C pin 2 tokens.",
  Gpioc2Tokens,
  gpioc,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpioc_afrl_afrl2,
  gpioc_brr_br2,
  gpioc_bsrr_br2,
  gpioc_bsrr_bs2,
  gpioc_crl_cnf2,
  gpioc_crl_mode2,
  gpioc_idr_idr2,
  gpioc_lckr_lck2,
  gpioc_moder_moder2,
  gpioc_odr_odr2,
  gpioc_ospeedr_ospeedr2,
  gpioc_otyper_ot2,
  gpioc_pupdr_pupdr2,
  gpioc_afrl,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crl,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  ((
    Asc2,
    gpioc_ascr_asc2,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 3.",
  Gpioc3,
  peripheral_gpioc_3,
  "GPIO port C pin 3 tokens.",
  Gpioc3Tokens,
  gpioc,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpioc_afrl_afrl3,
  gpioc_brr_br3,
  gpioc_bsrr_br3,
  gpioc_bsrr_bs3,
  gpioc_crl_cnf3,
  gpioc_crl_mode3,
  gpioc_idr_idr3,
  gpioc_lckr_lck3,
  gpioc_moder_moder3,
  gpioc_odr_odr3,
  gpioc_ospeedr_ospeedr3,
  gpioc_otyper_ot3,
  gpioc_pupdr_pupdr3,
  gpioc_afrl,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crl,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  ((
    Asc3,
    gpioc_ascr_asc3,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 4.",
  Gpioc4,
  peripheral_gpioc_4,
  "GPIO port C pin 4 tokens.",
  Gpioc4Tokens,
  gpioc,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpioc_afrl_afrl4,
  gpioc_brr_br4,
  gpioc_bsrr_br4,
  gpioc_bsrr_bs4,
  gpioc_crl_cnf4,
  gpioc_crl_mode4,
  gpioc_idr_idr4,
  gpioc_lckr_lck4,
  gpioc_moder_moder4,
  gpioc_odr_odr4,
  gpioc_ospeedr_ospeedr4,
  gpioc_otyper_ot4,
  gpioc_pupdr_pupdr4,
  gpioc_afrl,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crl,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  ((
    Asc4,
    gpioc_ascr_asc4,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 5.",
  Gpioc5,
  peripheral_gpioc_5,
  "GPIO port C pin 5 tokens.",
  Gpioc5Tokens,
  gpioc,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpioc_afrl_afrl5,
  gpioc_brr_br5,
  gpioc_bsrr_br5,
  gpioc_bsrr_bs5,
  gpioc_crl_cnf5,
  gpioc_crl_mode5,
  gpioc_idr_idr5,
  gpioc_lckr_lck5,
  gpioc_moder_moder5,
  gpioc_odr_odr5,
  gpioc_ospeedr_ospeedr5,
  gpioc_otyper_ot5,
  gpioc_pupdr_pupdr5,
  gpioc_afrl,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crl,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  ((
    Asc5,
    gpioc_ascr_asc5,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 6.",
  Gpioc6,
  peripheral_gpioc_6,
  "GPIO port C pin 6 tokens.",
  Gpioc6Tokens,
  gpioc,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpioc_afrl_afrl6,
  gpioc_brr_br6,
  gpioc_bsrr_br6,
  gpioc_bsrr_bs6,
  gpioc_crl_cnf6,
  gpioc_crl_mode6,
  gpioc_idr_idr6,
  gpioc_lckr_lck6,
  gpioc_moder_moder6,
  gpioc_odr_odr6,
  gpioc_ospeedr_ospeedr6,
  gpioc_otyper_ot6,
  gpioc_pupdr_pupdr6,
  gpioc_afrl,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crl,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  ((
    Asc6,
    gpioc_ascr_asc6,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 7.",
  Gpioc7,
  peripheral_gpioc_7,
  "GPIO port C pin 7 tokens.",
  Gpioc7Tokens,
  gpioc,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpioc_afrl_afrl7,
  gpioc_brr_br7,
  gpioc_bsrr_br7,
  gpioc_bsrr_bs7,
  gpioc_crl_cnf7,
  gpioc_crl_mode7,
  gpioc_idr_idr7,
  gpioc_lckr_lck7,
  gpioc_moder_moder7,
  gpioc_odr_odr7,
  gpioc_ospeedr_ospeedr7,
  gpioc_otyper_ot7,
  gpioc_pupdr_pupdr7,
  gpioc_afrl,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crl,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  ((
    Asc7,
    gpioc_ascr_asc7,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 8.",
  Gpioc8,
  peripheral_gpioc_8,
  "GPIO port C pin 8 tokens.",
  Gpioc8Tokens,
  gpioc,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpioc_afrh_afrh8,
  gpioc_brr_br8,
  gpioc_bsrr_br8,
  gpioc_bsrr_bs8,
  gpioc_crh_cnf8,
  gpioc_crh_mode8,
  gpioc_idr_idr8,
  gpioc_lckr_lck8,
  gpioc_moder_moder8,
  gpioc_odr_odr8,
  gpioc_ospeedr_ospeedr8,
  gpioc_otyper_ot8,
  gpioc_pupdr_pupdr8,
  gpioc_afrh,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crh,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  ((
    Asc8,
    gpioc_ascr_asc8,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 9.",
  Gpioc9,
  peripheral_gpioc_9,
  "GPIO port C pin 9 tokens.",
  Gpioc9Tokens,
  gpioc,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpioc_afrh_afrh9,
  gpioc_brr_br9,
  gpioc_bsrr_br9,
  gpioc_bsrr_bs9,
  gpioc_crh_cnf9,
  gpioc_crh_mode9,
  gpioc_idr_idr9,
  gpioc_lckr_lck9,
  gpioc_moder_moder9,
  gpioc_odr_odr9,
  gpioc_ospeedr_ospeedr9,
  gpioc_otyper_ot9,
  gpioc_pupdr_pupdr9,
  gpioc_afrh,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crh,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  ((
    Asc9,
    gpioc_ascr_asc9,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 10.",
  Gpioc10,
  peripheral_gpioc_10,
  "GPIO port C pin 10 tokens.",
  Gpioc10Tokens,
  gpioc,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpioc_afrh_afrh10,
  gpioc_brr_br10,
  gpioc_bsrr_br10,
  gpioc_bsrr_bs10,
  gpioc_crh_cnf10,
  gpioc_crh_mode10,
  gpioc_idr_idr10,
  gpioc_lckr_lck10,
  gpioc_moder_moder10,
  gpioc_odr_odr10,
  gpioc_ospeedr_ospeedr10,
  gpioc_otyper_ot10,
  gpioc_pupdr_pupdr10,
  gpioc_afrh,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crh,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  ((
    Asc10,
    gpioc_ascr_asc10,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 11.",
  Gpioc11,
  peripheral_gpioc_11,
  "GPIO port C pin 11 tokens.",
  Gpioc11Tokens,
  gpioc,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpioc_afrh_afrh11,
  gpioc_brr_br11,
  gpioc_bsrr_br11,
  gpioc_bsrr_bs11,
  gpioc_crh_cnf11,
  gpioc_crh_mode11,
  gpioc_idr_idr11,
  gpioc_lckr_lck11,
  gpioc_moder_moder11,
  gpioc_odr_odr11,
  gpioc_ospeedr_ospeedr11,
  gpioc_otyper_ot11,
  gpioc_pupdr_pupdr11,
  gpioc_afrh,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crh,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  ((
    Asc11,
    gpioc_ascr_asc11,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 12.",
  Gpioc12,
  peripheral_gpioc_12,
  "GPIO port C pin 12 tokens.",
  Gpioc12Tokens,
  gpioc,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpioc_afrh_afrh12,
  gpioc_brr_br12,
  gpioc_bsrr_br12,
  gpioc_bsrr_bs12,
  gpioc_crh_cnf12,
  gpioc_crh_mode12,
  gpioc_idr_idr12,
  gpioc_lckr_lck12,
  gpioc_moder_moder12,
  gpioc_odr_odr12,
  gpioc_ospeedr_ospeedr12,
  gpioc_otyper_ot12,
  gpioc_pupdr_pupdr12,
  gpioc_afrh,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crh,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  ((
    Asc12,
    gpioc_ascr_asc12,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 13.",
  Gpioc13,
  peripheral_gpioc_13,
  "GPIO port C pin 13 tokens.",
  Gpioc13Tokens,
  gpioc,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpioc_afrh_afrh13,
  gpioc_brr_br13,
  gpioc_bsrr_br13,
  gpioc_bsrr_bs13,
  gpioc_crh_cnf13,
  gpioc_crh_mode13,
  gpioc_idr_idr13,
  gpioc_lckr_lck13,
  gpioc_moder_moder13,
  gpioc_odr_odr13,
  gpioc_ospeedr_ospeedr13,
  gpioc_otyper_ot13,
  gpioc_pupdr_pupdr13,
  gpioc_afrh,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crh,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  ((
    Asc13,
    gpioc_ascr_asc13,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 14.",
  Gpioc14,
  peripheral_gpioc_14,
  "GPIO port C pin 14 tokens.",
  Gpioc14Tokens,
  gpioc,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpioc_afrh_afrh14,
  gpioc_brr_br14,
  gpioc_bsrr_br14,
  gpioc_bsrr_bs14,
  gpioc_crh_cnf14,
  gpioc_crh_mode14,
  gpioc_idr_idr14,
  gpioc_lckr_lck14,
  gpioc_moder_moder14,
  gpioc_odr_odr14,
  gpioc_ospeedr_ospeedr14,
  gpioc_otyper_ot14,
  gpioc_pupdr_pupdr14,
  gpioc_afrh,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crh,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  ((
    Asc14,
    gpioc_ascr_asc14,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port C pin 15.",
  Gpioc15,
  peripheral_gpioc_15,
  "GPIO port C pin 15 tokens.",
  Gpioc15Tokens,
  gpioc,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpioc_afrh_afrh15,
  gpioc_brr_br15,
  gpioc_bsrr_br15,
  gpioc_bsrr_bs15,
  gpioc_crh_cnf15,
  gpioc_crh_mode15,
  gpioc_idr_idr15,
  gpioc_lckr_lck15,
  gpioc_moder_moder15,
  gpioc_odr_odr15,
  gpioc_ospeedr_ospeedr15,
  gpioc_otyper_ot15,
  gpioc_pupdr_pupdr15,
  gpioc_afrh,
  gpioc_ascr,
  gpioc_brr,
  gpioc_bsrr,
  gpioc_crh,
  gpioc_idr,
  gpioc_lckr,
  gpioc_moder,
  gpioc_odr,
  gpioc_ospeedr,
  gpioc_otyper,
  gpioc_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  ((
    Asc15,
    gpioc_ascr_asc15,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 0.",
  Gpiod0,
  peripheral_gpiod_0,
  "GPIO port D pin 0 tokens.",
  Gpiod0Tokens,
  gpiod,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpiod_afrl_afrl0,
  gpiod_brr_br0,
  gpiod_bsrr_br0,
  gpiod_bsrr_bs0,
  gpiod_crl_cnf0,
  gpiod_crl_mode0,
  gpiod_idr_idr0,
  gpiod_lckr_lck0,
  gpiod_moder_moder0,
  gpiod_odr_odr0,
  gpiod_ospeedr_ospeedr0,
  gpiod_otyper_ot0,
  gpiod_pupdr_pupdr0,
  gpiod_afrl,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crl,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  ((
    Asc0,
    gpiod_ascr_asc0,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 1.",
  Gpiod1,
  peripheral_gpiod_1,
  "GPIO port D pin 1 tokens.",
  Gpiod1Tokens,
  gpiod,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpiod_afrl_afrl1,
  gpiod_brr_br1,
  gpiod_bsrr_br1,
  gpiod_bsrr_bs1,
  gpiod_crl_cnf1,
  gpiod_crl_mode1,
  gpiod_idr_idr1,
  gpiod_lckr_lck1,
  gpiod_moder_moder1,
  gpiod_odr_odr1,
  gpiod_ospeedr_ospeedr1,
  gpiod_otyper_ot1,
  gpiod_pupdr_pupdr1,
  gpiod_afrl,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crl,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  ((
    Asc1,
    gpiod_ascr_asc1,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 2.",
  Gpiod2,
  peripheral_gpiod_2,
  "GPIO port D pin 2 tokens.",
  Gpiod2Tokens,
  gpiod,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpiod_afrl_afrl2,
  gpiod_brr_br2,
  gpiod_bsrr_br2,
  gpiod_bsrr_bs2,
  gpiod_crl_cnf2,
  gpiod_crl_mode2,
  gpiod_idr_idr2,
  gpiod_lckr_lck2,
  gpiod_moder_moder2,
  gpiod_odr_odr2,
  gpiod_ospeedr_ospeedr2,
  gpiod_otyper_ot2,
  gpiod_pupdr_pupdr2,
  gpiod_afrl,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crl,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  ((
    Asc2,
    gpiod_ascr_asc2,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 3.",
  Gpiod3,
  peripheral_gpiod_3,
  "GPIO port D pin 3 tokens.",
  Gpiod3Tokens,
  gpiod,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpiod_afrl_afrl3,
  gpiod_brr_br3,
  gpiod_bsrr_br3,
  gpiod_bsrr_bs3,
  gpiod_crl_cnf3,
  gpiod_crl_mode3,
  gpiod_idr_idr3,
  gpiod_lckr_lck3,
  gpiod_moder_moder3,
  gpiod_odr_odr3,
  gpiod_ospeedr_ospeedr3,
  gpiod_otyper_ot3,
  gpiod_pupdr_pupdr3,
  gpiod_afrl,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crl,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  ((
    Asc3,
    gpiod_ascr_asc3,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 4.",
  Gpiod4,
  peripheral_gpiod_4,
  "GPIO port D pin 4 tokens.",
  Gpiod4Tokens,
  gpiod,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpiod_afrl_afrl4,
  gpiod_brr_br4,
  gpiod_bsrr_br4,
  gpiod_bsrr_bs4,
  gpiod_crl_cnf4,
  gpiod_crl_mode4,
  gpiod_idr_idr4,
  gpiod_lckr_lck4,
  gpiod_moder_moder4,
  gpiod_odr_odr4,
  gpiod_ospeedr_ospeedr4,
  gpiod_otyper_ot4,
  gpiod_pupdr_pupdr4,
  gpiod_afrl,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crl,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  ((
    Asc4,
    gpiod_ascr_asc4,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 5.",
  Gpiod5,
  peripheral_gpiod_5,
  "GPIO port D pin 5 tokens.",
  Gpiod5Tokens,
  gpiod,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpiod_afrl_afrl5,
  gpiod_brr_br5,
  gpiod_bsrr_br5,
  gpiod_bsrr_bs5,
  gpiod_crl_cnf5,
  gpiod_crl_mode5,
  gpiod_idr_idr5,
  gpiod_lckr_lck5,
  gpiod_moder_moder5,
  gpiod_odr_odr5,
  gpiod_ospeedr_ospeedr5,
  gpiod_otyper_ot5,
  gpiod_pupdr_pupdr5,
  gpiod_afrl,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crl,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  ((
    Asc5,
    gpiod_ascr_asc5,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 6.",
  Gpiod6,
  peripheral_gpiod_6,
  "GPIO port D pin 6 tokens.",
  Gpiod6Tokens,
  gpiod,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpiod_afrl_afrl6,
  gpiod_brr_br6,
  gpiod_bsrr_br6,
  gpiod_bsrr_bs6,
  gpiod_crl_cnf6,
  gpiod_crl_mode6,
  gpiod_idr_idr6,
  gpiod_lckr_lck6,
  gpiod_moder_moder6,
  gpiod_odr_odr6,
  gpiod_ospeedr_ospeedr6,
  gpiod_otyper_ot6,
  gpiod_pupdr_pupdr6,
  gpiod_afrl,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crl,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  ((
    Asc6,
    gpiod_ascr_asc6,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 7.",
  Gpiod7,
  peripheral_gpiod_7,
  "GPIO port D pin 7 tokens.",
  Gpiod7Tokens,
  gpiod,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpiod_afrl_afrl7,
  gpiod_brr_br7,
  gpiod_bsrr_br7,
  gpiod_bsrr_bs7,
  gpiod_crl_cnf7,
  gpiod_crl_mode7,
  gpiod_idr_idr7,
  gpiod_lckr_lck7,
  gpiod_moder_moder7,
  gpiod_odr_odr7,
  gpiod_ospeedr_ospeedr7,
  gpiod_otyper_ot7,
  gpiod_pupdr_pupdr7,
  gpiod_afrl,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crl,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  ((
    Asc7,
    gpiod_ascr_asc7,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 8.",
  Gpiod8,
  peripheral_gpiod_8,
  "GPIO port D pin 8 tokens.",
  Gpiod8Tokens,
  gpiod,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpiod_afrh_afrh8,
  gpiod_brr_br8,
  gpiod_bsrr_br8,
  gpiod_bsrr_bs8,
  gpiod_crh_cnf8,
  gpiod_crh_mode8,
  gpiod_idr_idr8,
  gpiod_lckr_lck8,
  gpiod_moder_moder8,
  gpiod_odr_odr8,
  gpiod_ospeedr_ospeedr8,
  gpiod_otyper_ot8,
  gpiod_pupdr_pupdr8,
  gpiod_afrh,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crh,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  ((
    Asc8,
    gpiod_ascr_asc8,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 9.",
  Gpiod9,
  peripheral_gpiod_9,
  "GPIO port D pin 9 tokens.",
  Gpiod9Tokens,
  gpiod,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpiod_afrh_afrh9,
  gpiod_brr_br9,
  gpiod_bsrr_br9,
  gpiod_bsrr_bs9,
  gpiod_crh_cnf9,
  gpiod_crh_mode9,
  gpiod_idr_idr9,
  gpiod_lckr_lck9,
  gpiod_moder_moder9,
  gpiod_odr_odr9,
  gpiod_ospeedr_ospeedr9,
  gpiod_otyper_ot9,
  gpiod_pupdr_pupdr9,
  gpiod_afrh,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crh,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  ((
    Asc9,
    gpiod_ascr_asc9,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 10.",
  Gpiod10,
  peripheral_gpiod_10,
  "GPIO port D pin 10 tokens.",
  Gpiod10Tokens,
  gpiod,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpiod_afrh_afrh10,
  gpiod_brr_br10,
  gpiod_bsrr_br10,
  gpiod_bsrr_bs10,
  gpiod_crh_cnf10,
  gpiod_crh_mode10,
  gpiod_idr_idr10,
  gpiod_lckr_lck10,
  gpiod_moder_moder10,
  gpiod_odr_odr10,
  gpiod_ospeedr_ospeedr10,
  gpiod_otyper_ot10,
  gpiod_pupdr_pupdr10,
  gpiod_afrh,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crh,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  ((
    Asc10,
    gpiod_ascr_asc10,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 11.",
  Gpiod11,
  peripheral_gpiod_11,
  "GPIO port D pin 11 tokens.",
  Gpiod11Tokens,
  gpiod,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpiod_afrh_afrh11,
  gpiod_brr_br11,
  gpiod_bsrr_br11,
  gpiod_bsrr_bs11,
  gpiod_crh_cnf11,
  gpiod_crh_mode11,
  gpiod_idr_idr11,
  gpiod_lckr_lck11,
  gpiod_moder_moder11,
  gpiod_odr_odr11,
  gpiod_ospeedr_ospeedr11,
  gpiod_otyper_ot11,
  gpiod_pupdr_pupdr11,
  gpiod_afrh,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crh,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  ((
    Asc11,
    gpiod_ascr_asc11,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 12.",
  Gpiod12,
  peripheral_gpiod_12,
  "GPIO port D pin 12 tokens.",
  Gpiod12Tokens,
  gpiod,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpiod_afrh_afrh12,
  gpiod_brr_br12,
  gpiod_bsrr_br12,
  gpiod_bsrr_bs12,
  gpiod_crh_cnf12,
  gpiod_crh_mode12,
  gpiod_idr_idr12,
  gpiod_lckr_lck12,
  gpiod_moder_moder12,
  gpiod_odr_odr12,
  gpiod_ospeedr_ospeedr12,
  gpiod_otyper_ot12,
  gpiod_pupdr_pupdr12,
  gpiod_afrh,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crh,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  ((
    Asc12,
    gpiod_ascr_asc12,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 13.",
  Gpiod13,
  peripheral_gpiod_13,
  "GPIO port D pin 13 tokens.",
  Gpiod13Tokens,
  gpiod,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpiod_afrh_afrh13,
  gpiod_brr_br13,
  gpiod_bsrr_br13,
  gpiod_bsrr_bs13,
  gpiod_crh_cnf13,
  gpiod_crh_mode13,
  gpiod_idr_idr13,
  gpiod_lckr_lck13,
  gpiod_moder_moder13,
  gpiod_odr_odr13,
  gpiod_ospeedr_ospeedr13,
  gpiod_otyper_ot13,
  gpiod_pupdr_pupdr13,
  gpiod_afrh,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crh,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  ((
    Asc13,
    gpiod_ascr_asc13,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 14.",
  Gpiod14,
  peripheral_gpiod_14,
  "GPIO port D pin 14 tokens.",
  Gpiod14Tokens,
  gpiod,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpiod_afrh_afrh14,
  gpiod_brr_br14,
  gpiod_bsrr_br14,
  gpiod_bsrr_bs14,
  gpiod_crh_cnf14,
  gpiod_crh_mode14,
  gpiod_idr_idr14,
  gpiod_lckr_lck14,
  gpiod_moder_moder14,
  gpiod_odr_odr14,
  gpiod_ospeedr_ospeedr14,
  gpiod_otyper_ot14,
  gpiod_pupdr_pupdr14,
  gpiod_afrh,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crh,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  ((
    Asc14,
    gpiod_ascr_asc14,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port D pin 15.",
  Gpiod15,
  peripheral_gpiod_15,
  "GPIO port D pin 15 tokens.",
  Gpiod15Tokens,
  gpiod,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpiod_afrh_afrh15,
  gpiod_brr_br15,
  gpiod_bsrr_br15,
  gpiod_bsrr_bs15,
  gpiod_crh_cnf15,
  gpiod_crh_mode15,
  gpiod_idr_idr15,
  gpiod_lckr_lck15,
  gpiod_moder_moder15,
  gpiod_odr_odr15,
  gpiod_ospeedr_ospeedr15,
  gpiod_otyper_ot15,
  gpiod_pupdr_pupdr15,
  gpiod_afrh,
  gpiod_ascr,
  gpiod_brr,
  gpiod_bsrr,
  gpiod_crh,
  gpiod_idr,
  gpiod_lckr,
  gpiod_moder,
  gpiod_odr,
  gpiod_ospeedr,
  gpiod_otyper,
  gpiod_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  ((
    Asc15,
    gpiod_ascr_asc15,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 0.",
  Gpioe0,
  peripheral_gpioe_0,
  "GPIO port E pin 0 tokens.",
  Gpioe0Tokens,
  gpioe,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpioe_afrl_afrl0,
  gpioe_brr_br0,
  gpioe_bsrr_br0,
  gpioe_bsrr_bs0,
  gpioe_crl_cnf0,
  gpioe_crl_mode0,
  gpioe_idr_idr0,
  gpioe_lckr_lck0,
  gpioe_moder_moder0,
  gpioe_odr_odr0,
  gpioe_ospeedr_ospeedr0,
  gpioe_otyper_ot0,
  gpioe_pupdr_pupdr0,
  gpioe_afrl,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crl,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  ((
    Asc0,
    gpioe_ascr_asc0,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 1.",
  Gpioe1,
  peripheral_gpioe_1,
  "GPIO port E pin 1 tokens.",
  Gpioe1Tokens,
  gpioe,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpioe_afrl_afrl1,
  gpioe_brr_br1,
  gpioe_bsrr_br1,
  gpioe_bsrr_bs1,
  gpioe_crl_cnf1,
  gpioe_crl_mode1,
  gpioe_idr_idr1,
  gpioe_lckr_lck1,
  gpioe_moder_moder1,
  gpioe_odr_odr1,
  gpioe_ospeedr_ospeedr1,
  gpioe_otyper_ot1,
  gpioe_pupdr_pupdr1,
  gpioe_afrl,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crl,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  ((
    Asc1,
    gpioe_ascr_asc1,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 2.",
  Gpioe2,
  peripheral_gpioe_2,
  "GPIO port E pin 2 tokens.",
  Gpioe2Tokens,
  gpioe,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpioe_afrl_afrl2,
  gpioe_brr_br2,
  gpioe_bsrr_br2,
  gpioe_bsrr_bs2,
  gpioe_crl_cnf2,
  gpioe_crl_mode2,
  gpioe_idr_idr2,
  gpioe_lckr_lck2,
  gpioe_moder_moder2,
  gpioe_odr_odr2,
  gpioe_ospeedr_ospeedr2,
  gpioe_otyper_ot2,
  gpioe_pupdr_pupdr2,
  gpioe_afrl,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crl,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  ((
    Asc2,
    gpioe_ascr_asc2,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 3.",
  Gpioe3,
  peripheral_gpioe_3,
  "GPIO port E pin 3 tokens.",
  Gpioe3Tokens,
  gpioe,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpioe_afrl_afrl3,
  gpioe_brr_br3,
  gpioe_bsrr_br3,
  gpioe_bsrr_bs3,
  gpioe_crl_cnf3,
  gpioe_crl_mode3,
  gpioe_idr_idr3,
  gpioe_lckr_lck3,
  gpioe_moder_moder3,
  gpioe_odr_odr3,
  gpioe_ospeedr_ospeedr3,
  gpioe_otyper_ot3,
  gpioe_pupdr_pupdr3,
  gpioe_afrl,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crl,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  ((
    Asc3,
    gpioe_ascr_asc3,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 4.",
  Gpioe4,
  peripheral_gpioe_4,
  "GPIO port E pin 4 tokens.",
  Gpioe4Tokens,
  gpioe,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpioe_afrl_afrl4,
  gpioe_brr_br4,
  gpioe_bsrr_br4,
  gpioe_bsrr_bs4,
  gpioe_crl_cnf4,
  gpioe_crl_mode4,
  gpioe_idr_idr4,
  gpioe_lckr_lck4,
  gpioe_moder_moder4,
  gpioe_odr_odr4,
  gpioe_ospeedr_ospeedr4,
  gpioe_otyper_ot4,
  gpioe_pupdr_pupdr4,
  gpioe_afrl,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crl,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  ((
    Asc4,
    gpioe_ascr_asc4,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 5.",
  Gpioe5,
  peripheral_gpioe_5,
  "GPIO port E pin 5 tokens.",
  Gpioe5Tokens,
  gpioe,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpioe_afrl_afrl5,
  gpioe_brr_br5,
  gpioe_bsrr_br5,
  gpioe_bsrr_bs5,
  gpioe_crl_cnf5,
  gpioe_crl_mode5,
  gpioe_idr_idr5,
  gpioe_lckr_lck5,
  gpioe_moder_moder5,
  gpioe_odr_odr5,
  gpioe_ospeedr_ospeedr5,
  gpioe_otyper_ot5,
  gpioe_pupdr_pupdr5,
  gpioe_afrl,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crl,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  ((
    Asc5,
    gpioe_ascr_asc5,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 6.",
  Gpioe6,
  peripheral_gpioe_6,
  "GPIO port E pin 6 tokens.",
  Gpioe6Tokens,
  gpioe,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpioe_afrl_afrl6,
  gpioe_brr_br6,
  gpioe_bsrr_br6,
  gpioe_bsrr_bs6,
  gpioe_crl_cnf6,
  gpioe_crl_mode6,
  gpioe_idr_idr6,
  gpioe_lckr_lck6,
  gpioe_moder_moder6,
  gpioe_odr_odr6,
  gpioe_ospeedr_ospeedr6,
  gpioe_otyper_ot6,
  gpioe_pupdr_pupdr6,
  gpioe_afrl,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crl,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  ((
    Asc6,
    gpioe_ascr_asc6,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 7.",
  Gpioe7,
  peripheral_gpioe_7,
  "GPIO port E pin 7 tokens.",
  Gpioe7Tokens,
  gpioe,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpioe_afrl_afrl7,
  gpioe_brr_br7,
  gpioe_bsrr_br7,
  gpioe_bsrr_bs7,
  gpioe_crl_cnf7,
  gpioe_crl_mode7,
  gpioe_idr_idr7,
  gpioe_lckr_lck7,
  gpioe_moder_moder7,
  gpioe_odr_odr7,
  gpioe_ospeedr_ospeedr7,
  gpioe_otyper_ot7,
  gpioe_pupdr_pupdr7,
  gpioe_afrl,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crl,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  ((
    Asc7,
    gpioe_ascr_asc7,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 8.",
  Gpioe8,
  peripheral_gpioe_8,
  "GPIO port E pin 8 tokens.",
  Gpioe8Tokens,
  gpioe,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpioe_afrh_afrh8,
  gpioe_brr_br8,
  gpioe_bsrr_br8,
  gpioe_bsrr_bs8,
  gpioe_crh_cnf8,
  gpioe_crh_mode8,
  gpioe_idr_idr8,
  gpioe_lckr_lck8,
  gpioe_moder_moder8,
  gpioe_odr_odr8,
  gpioe_ospeedr_ospeedr8,
  gpioe_otyper_ot8,
  gpioe_pupdr_pupdr8,
  gpioe_afrh,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crh,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  ((
    Asc8,
    gpioe_ascr_asc8,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 9.",
  Gpioe9,
  peripheral_gpioe_9,
  "GPIO port E pin 9 tokens.",
  Gpioe9Tokens,
  gpioe,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpioe_afrh_afrh9,
  gpioe_brr_br9,
  gpioe_bsrr_br9,
  gpioe_bsrr_bs9,
  gpioe_crh_cnf9,
  gpioe_crh_mode9,
  gpioe_idr_idr9,
  gpioe_lckr_lck9,
  gpioe_moder_moder9,
  gpioe_odr_odr9,
  gpioe_ospeedr_ospeedr9,
  gpioe_otyper_ot9,
  gpioe_pupdr_pupdr9,
  gpioe_afrh,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crh,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  ((
    Asc9,
    gpioe_ascr_asc9,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 10.",
  Gpioe10,
  peripheral_gpioe_10,
  "GPIO port E pin 10 tokens.",
  Gpioe10Tokens,
  gpioe,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpioe_afrh_afrh10,
  gpioe_brr_br10,
  gpioe_bsrr_br10,
  gpioe_bsrr_bs10,
  gpioe_crh_cnf10,
  gpioe_crh_mode10,
  gpioe_idr_idr10,
  gpioe_lckr_lck10,
  gpioe_moder_moder10,
  gpioe_odr_odr10,
  gpioe_ospeedr_ospeedr10,
  gpioe_otyper_ot10,
  gpioe_pupdr_pupdr10,
  gpioe_afrh,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crh,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  ((
    Asc10,
    gpioe_ascr_asc10,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 11.",
  Gpioe11,
  peripheral_gpioe_11,
  "GPIO port E pin 11 tokens.",
  Gpioe11Tokens,
  gpioe,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpioe_afrh_afrh11,
  gpioe_brr_br11,
  gpioe_bsrr_br11,
  gpioe_bsrr_bs11,
  gpioe_crh_cnf11,
  gpioe_crh_mode11,
  gpioe_idr_idr11,
  gpioe_lckr_lck11,
  gpioe_moder_moder11,
  gpioe_odr_odr11,
  gpioe_ospeedr_ospeedr11,
  gpioe_otyper_ot11,
  gpioe_pupdr_pupdr11,
  gpioe_afrh,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crh,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  ((
    Asc11,
    gpioe_ascr_asc11,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 12.",
  Gpioe12,
  peripheral_gpioe_12,
  "GPIO port E pin 12 tokens.",
  Gpioe12Tokens,
  gpioe,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpioe_afrh_afrh12,
  gpioe_brr_br12,
  gpioe_bsrr_br12,
  gpioe_bsrr_bs12,
  gpioe_crh_cnf12,
  gpioe_crh_mode12,
  gpioe_idr_idr12,
  gpioe_lckr_lck12,
  gpioe_moder_moder12,
  gpioe_odr_odr12,
  gpioe_ospeedr_ospeedr12,
  gpioe_otyper_ot12,
  gpioe_pupdr_pupdr12,
  gpioe_afrh,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crh,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  ((
    Asc12,
    gpioe_ascr_asc12,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 13.",
  Gpioe13,
  peripheral_gpioe_13,
  "GPIO port E pin 13 tokens.",
  Gpioe13Tokens,
  gpioe,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpioe_afrh_afrh13,
  gpioe_brr_br13,
  gpioe_bsrr_br13,
  gpioe_bsrr_bs13,
  gpioe_crh_cnf13,
  gpioe_crh_mode13,
  gpioe_idr_idr13,
  gpioe_lckr_lck13,
  gpioe_moder_moder13,
  gpioe_odr_odr13,
  gpioe_ospeedr_ospeedr13,
  gpioe_otyper_ot13,
  gpioe_pupdr_pupdr13,
  gpioe_afrh,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crh,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  ((
    Asc13,
    gpioe_ascr_asc13,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 14.",
  Gpioe14,
  peripheral_gpioe_14,
  "GPIO port E pin 14 tokens.",
  Gpioe14Tokens,
  gpioe,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpioe_afrh_afrh14,
  gpioe_brr_br14,
  gpioe_bsrr_br14,
  gpioe_bsrr_bs14,
  gpioe_crh_cnf14,
  gpioe_crh_mode14,
  gpioe_idr_idr14,
  gpioe_lckr_lck14,
  gpioe_moder_moder14,
  gpioe_odr_odr14,
  gpioe_ospeedr_ospeedr14,
  gpioe_otyper_ot14,
  gpioe_pupdr_pupdr14,
  gpioe_afrh,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crh,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  ((
    Asc14,
    gpioe_ascr_asc14,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x1",
          feature = "stm32l4x2", feature = "stm32l4x3",
          feature = "stm32l4x5", feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port E pin 15.",
  Gpioe15,
  peripheral_gpioe_15,
  "GPIO port E pin 15 tokens.",
  Gpioe15Tokens,
  gpioe,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpioe_afrh_afrh15,
  gpioe_brr_br15,
  gpioe_bsrr_br15,
  gpioe_bsrr_bs15,
  gpioe_crh_cnf15,
  gpioe_crh_mode15,
  gpioe_idr_idr15,
  gpioe_lckr_lck15,
  gpioe_moder_moder15,
  gpioe_odr_odr15,
  gpioe_ospeedr_ospeedr15,
  gpioe_otyper_ot15,
  gpioe_pupdr_pupdr15,
  gpioe_afrh,
  gpioe_ascr,
  gpioe_brr,
  gpioe_bsrr,
  gpioe_crh,
  gpioe_idr,
  gpioe_lckr,
  gpioe_moder,
  gpioe_odr,
  gpioe_ospeedr,
  gpioe_otyper,
  gpioe_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  ((
    Asc15,
    gpioe_ascr_asc15,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 0.",
  Gpiof0,
  peripheral_gpiof_0,
  "GPIO port F pin 0 tokens.",
  Gpiof0Tokens,
  gpiof,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpiof_afrl_afrl0,
  gpiof_brr_br0,
  gpiof_bsrr_br0,
  gpiof_bsrr_bs0,
  gpiof_crl_cnf0,
  gpiof_crl_mode0,
  gpiof_idr_idr0,
  gpiof_lckr_lck0,
  gpiof_moder_moder0,
  gpiof_odr_odr0,
  gpiof_ospeedr_ospeedr0,
  gpiof_otyper_ot0,
  gpiof_pupdr_pupdr0,
  gpiof_afrl,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crl,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  ((
    Asc0,
    gpiof_ascr_asc0,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 1.",
  Gpiof1,
  peripheral_gpiof_1,
  "GPIO port F pin 1 tokens.",
  Gpiof1Tokens,
  gpiof,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpiof_afrl_afrl1,
  gpiof_brr_br1,
  gpiof_bsrr_br1,
  gpiof_bsrr_bs1,
  gpiof_crl_cnf1,
  gpiof_crl_mode1,
  gpiof_idr_idr1,
  gpiof_lckr_lck1,
  gpiof_moder_moder1,
  gpiof_odr_odr1,
  gpiof_ospeedr_ospeedr1,
  gpiof_otyper_ot1,
  gpiof_pupdr_pupdr1,
  gpiof_afrl,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crl,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  ((
    Asc1,
    gpiof_ascr_asc1,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 2.",
  Gpiof2,
  peripheral_gpiof_2,
  "GPIO port F pin 2 tokens.",
  Gpiof2Tokens,
  gpiof,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpiof_afrl_afrl2,
  gpiof_brr_br2,
  gpiof_bsrr_br2,
  gpiof_bsrr_bs2,
  gpiof_crl_cnf2,
  gpiof_crl_mode2,
  gpiof_idr_idr2,
  gpiof_lckr_lck2,
  gpiof_moder_moder2,
  gpiof_odr_odr2,
  gpiof_ospeedr_ospeedr2,
  gpiof_otyper_ot2,
  gpiof_pupdr_pupdr2,
  gpiof_afrl,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crl,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  ((
    Asc2,
    gpiof_ascr_asc2,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 3.",
  Gpiof3,
  peripheral_gpiof_3,
  "GPIO port F pin 3 tokens.",
  Gpiof3Tokens,
  gpiof,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpiof_afrl_afrl3,
  gpiof_brr_br3,
  gpiof_bsrr_br3,
  gpiof_bsrr_bs3,
  gpiof_crl_cnf3,
  gpiof_crl_mode3,
  gpiof_idr_idr3,
  gpiof_lckr_lck3,
  gpiof_moder_moder3,
  gpiof_odr_odr3,
  gpiof_ospeedr_ospeedr3,
  gpiof_otyper_ot3,
  gpiof_pupdr_pupdr3,
  gpiof_afrl,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crl,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  ((
    Asc3,
    gpiof_ascr_asc3,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 4.",
  Gpiof4,
  peripheral_gpiof_4,
  "GPIO port F pin 4 tokens.",
  Gpiof4Tokens,
  gpiof,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpiof_afrl_afrl4,
  gpiof_brr_br4,
  gpiof_bsrr_br4,
  gpiof_bsrr_bs4,
  gpiof_crl_cnf4,
  gpiof_crl_mode4,
  gpiof_idr_idr4,
  gpiof_lckr_lck4,
  gpiof_moder_moder4,
  gpiof_odr_odr4,
  gpiof_ospeedr_ospeedr4,
  gpiof_otyper_ot4,
  gpiof_pupdr_pupdr4,
  gpiof_afrl,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crl,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  ((
    Asc4,
    gpiof_ascr_asc4,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 5.",
  Gpiof5,
  peripheral_gpiof_5,
  "GPIO port F pin 5 tokens.",
  Gpiof5Tokens,
  gpiof,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpiof_afrl_afrl5,
  gpiof_brr_br5,
  gpiof_bsrr_br5,
  gpiof_bsrr_bs5,
  gpiof_crl_cnf5,
  gpiof_crl_mode5,
  gpiof_idr_idr5,
  gpiof_lckr_lck5,
  gpiof_moder_moder5,
  gpiof_odr_odr5,
  gpiof_ospeedr_ospeedr5,
  gpiof_otyper_ot5,
  gpiof_pupdr_pupdr5,
  gpiof_afrl,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crl,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  ((
    Asc5,
    gpiof_ascr_asc5,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 6.",
  Gpiof6,
  peripheral_gpiof_6,
  "GPIO port F pin 6 tokens.",
  Gpiof6Tokens,
  gpiof,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpiof_afrl_afrl6,
  gpiof_brr_br6,
  gpiof_bsrr_br6,
  gpiof_bsrr_bs6,
  gpiof_crl_cnf6,
  gpiof_crl_mode6,
  gpiof_idr_idr6,
  gpiof_lckr_lck6,
  gpiof_moder_moder6,
  gpiof_odr_odr6,
  gpiof_ospeedr_ospeedr6,
  gpiof_otyper_ot6,
  gpiof_pupdr_pupdr6,
  gpiof_afrl,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crl,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  ((
    Asc6,
    gpiof_ascr_asc6,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 7.",
  Gpiof7,
  peripheral_gpiof_7,
  "GPIO port F pin 7 tokens.",
  Gpiof7Tokens,
  gpiof,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpiof_afrl_afrl7,
  gpiof_brr_br7,
  gpiof_bsrr_br7,
  gpiof_bsrr_bs7,
  gpiof_crl_cnf7,
  gpiof_crl_mode7,
  gpiof_idr_idr7,
  gpiof_lckr_lck7,
  gpiof_moder_moder7,
  gpiof_odr_odr7,
  gpiof_ospeedr_ospeedr7,
  gpiof_otyper_ot7,
  gpiof_pupdr_pupdr7,
  gpiof_afrl,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crl,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  ((
    Asc7,
    gpiof_ascr_asc7,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 8.",
  Gpiof8,
  peripheral_gpiof_8,
  "GPIO port F pin 8 tokens.",
  Gpiof8Tokens,
  gpiof,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpiof_afrh_afrh8,
  gpiof_brr_br8,
  gpiof_bsrr_br8,
  gpiof_bsrr_bs8,
  gpiof_crh_cnf8,
  gpiof_crh_mode8,
  gpiof_idr_idr8,
  gpiof_lckr_lck8,
  gpiof_moder_moder8,
  gpiof_odr_odr8,
  gpiof_ospeedr_ospeedr8,
  gpiof_otyper_ot8,
  gpiof_pupdr_pupdr8,
  gpiof_afrh,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crh,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  ((
    Asc8,
    gpiof_ascr_asc8,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 9.",
  Gpiof9,
  peripheral_gpiof_9,
  "GPIO port F pin 9 tokens.",
  Gpiof9Tokens,
  gpiof,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpiof_afrh_afrh9,
  gpiof_brr_br9,
  gpiof_bsrr_br9,
  gpiof_bsrr_bs9,
  gpiof_crh_cnf9,
  gpiof_crh_mode9,
  gpiof_idr_idr9,
  gpiof_lckr_lck9,
  gpiof_moder_moder9,
  gpiof_odr_odr9,
  gpiof_ospeedr_ospeedr9,
  gpiof_otyper_ot9,
  gpiof_pupdr_pupdr9,
  gpiof_afrh,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crh,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  ((
    Asc9,
    gpiof_ascr_asc9,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 10.",
  Gpiof10,
  peripheral_gpiof_10,
  "GPIO port F pin 10 tokens.",
  Gpiof10Tokens,
  gpiof,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpiof_afrh_afrh10,
  gpiof_brr_br10,
  gpiof_bsrr_br10,
  gpiof_bsrr_bs10,
  gpiof_crh_cnf10,
  gpiof_crh_mode10,
  gpiof_idr_idr10,
  gpiof_lckr_lck10,
  gpiof_moder_moder10,
  gpiof_odr_odr10,
  gpiof_ospeedr_ospeedr10,
  gpiof_otyper_ot10,
  gpiof_pupdr_pupdr10,
  gpiof_afrh,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crh,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  ((
    Asc10,
    gpiof_ascr_asc10,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 11.",
  Gpiof11,
  peripheral_gpiof_11,
  "GPIO port F pin 11 tokens.",
  Gpiof11Tokens,
  gpiof,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpiof_afrh_afrh11,
  gpiof_brr_br11,
  gpiof_bsrr_br11,
  gpiof_bsrr_bs11,
  gpiof_crh_cnf11,
  gpiof_crh_mode11,
  gpiof_idr_idr11,
  gpiof_lckr_lck11,
  gpiof_moder_moder11,
  gpiof_odr_odr11,
  gpiof_ospeedr_ospeedr11,
  gpiof_otyper_ot11,
  gpiof_pupdr_pupdr11,
  gpiof_afrh,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crh,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  ((
    Asc11,
    gpiof_ascr_asc11,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 12.",
  Gpiof12,
  peripheral_gpiof_12,
  "GPIO port F pin 12 tokens.",
  Gpiof12Tokens,
  gpiof,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpiof_afrh_afrh12,
  gpiof_brr_br12,
  gpiof_bsrr_br12,
  gpiof_bsrr_bs12,
  gpiof_crh_cnf12,
  gpiof_crh_mode12,
  gpiof_idr_idr12,
  gpiof_lckr_lck12,
  gpiof_moder_moder12,
  gpiof_odr_odr12,
  gpiof_ospeedr_ospeedr12,
  gpiof_otyper_ot12,
  gpiof_pupdr_pupdr12,
  gpiof_afrh,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crh,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  ((
    Asc12,
    gpiof_ascr_asc12,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 13.",
  Gpiof13,
  peripheral_gpiof_13,
  "GPIO port F pin 13 tokens.",
  Gpiof13Tokens,
  gpiof,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpiof_afrh_afrh13,
  gpiof_brr_br13,
  gpiof_bsrr_br13,
  gpiof_bsrr_bs13,
  gpiof_crh_cnf13,
  gpiof_crh_mode13,
  gpiof_idr_idr13,
  gpiof_lckr_lck13,
  gpiof_moder_moder13,
  gpiof_odr_odr13,
  gpiof_ospeedr_ospeedr13,
  gpiof_otyper_ot13,
  gpiof_pupdr_pupdr13,
  gpiof_afrh,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crh,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  ((
    Asc13,
    gpiof_ascr_asc13,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 14.",
  Gpiof14,
  peripheral_gpiof_14,
  "GPIO port F pin 14 tokens.",
  Gpiof14Tokens,
  gpiof,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpiof_afrh_afrh14,
  gpiof_brr_br14,
  gpiof_bsrr_br14,
  gpiof_bsrr_bs14,
  gpiof_crh_cnf14,
  gpiof_crh_mode14,
  gpiof_idr_idr14,
  gpiof_lckr_lck14,
  gpiof_moder_moder14,
  gpiof_odr_odr14,
  gpiof_ospeedr_ospeedr14,
  gpiof_otyper_ot14,
  gpiof_pupdr_pupdr14,
  gpiof_afrh,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crh,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  ((
    Asc14,
    gpiof_ascr_asc14,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port F pin 15.",
  Gpiof15,
  peripheral_gpiof_15,
  "GPIO port F pin 15 tokens.",
  Gpiof15Tokens,
  gpiof,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpiof_afrh_afrh15,
  gpiof_brr_br15,
  gpiof_bsrr_br15,
  gpiof_bsrr_bs15,
  gpiof_crh_cnf15,
  gpiof_crh_mode15,
  gpiof_idr_idr15,
  gpiof_lckr_lck15,
  gpiof_moder_moder15,
  gpiof_odr_odr15,
  gpiof_ospeedr_ospeedr15,
  gpiof_otyper_ot15,
  gpiof_pupdr_pupdr15,
  gpiof_afrh,
  gpiof_ascr,
  gpiof_brr,
  gpiof_bsrr,
  gpiof_crh,
  gpiof_idr,
  gpiof_lckr,
  gpiof_moder,
  gpiof_odr,
  gpiof_ospeedr,
  gpiof_otyper,
  gpiof_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  ((
    Asc15,
    gpiof_ascr_asc15,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 0.",
  Gpiog0,
  peripheral_gpiog_0,
  "GPIO port G pin 0 tokens.",
  Gpiog0Tokens,
  gpiog,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpiog_afrl_afrl0,
  gpiog_brr_br0,
  gpiog_bsrr_br0,
  gpiog_bsrr_bs0,
  gpiog_crl_cnf0,
  gpiog_crl_mode0,
  gpiog_idr_idr0,
  gpiog_lckr_lck0,
  gpiog_moder_moder0,
  gpiog_odr_odr0,
  gpiog_ospeedr_ospeedr0,
  gpiog_otyper_ot0,
  gpiog_pupdr_pupdr0,
  gpiog_afrl,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crl,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  ((
    Asc0,
    gpiog_ascr_asc0,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 1.",
  Gpiog1,
  peripheral_gpiog_1,
  "GPIO port G pin 1 tokens.",
  Gpiog1Tokens,
  gpiog,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpiog_afrl_afrl1,
  gpiog_brr_br1,
  gpiog_bsrr_br1,
  gpiog_bsrr_bs1,
  gpiog_crl_cnf1,
  gpiog_crl_mode1,
  gpiog_idr_idr1,
  gpiog_lckr_lck1,
  gpiog_moder_moder1,
  gpiog_odr_odr1,
  gpiog_ospeedr_ospeedr1,
  gpiog_otyper_ot1,
  gpiog_pupdr_pupdr1,
  gpiog_afrl,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crl,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  ((
    Asc1,
    gpiog_ascr_asc1,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 2.",
  Gpiog2,
  peripheral_gpiog_2,
  "GPIO port G pin 2 tokens.",
  Gpiog2Tokens,
  gpiog,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpiog_afrl_afrl2,
  gpiog_brr_br2,
  gpiog_bsrr_br2,
  gpiog_bsrr_bs2,
  gpiog_crl_cnf2,
  gpiog_crl_mode2,
  gpiog_idr_idr2,
  gpiog_lckr_lck2,
  gpiog_moder_moder2,
  gpiog_odr_odr2,
  gpiog_ospeedr_ospeedr2,
  gpiog_otyper_ot2,
  gpiog_pupdr_pupdr2,
  gpiog_afrl,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crl,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  ((
    Asc2,
    gpiog_ascr_asc2,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 3.",
  Gpiog3,
  peripheral_gpiog_3,
  "GPIO port G pin 3 tokens.",
  Gpiog3Tokens,
  gpiog,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpiog_afrl_afrl3,
  gpiog_brr_br3,
  gpiog_bsrr_br3,
  gpiog_bsrr_bs3,
  gpiog_crl_cnf3,
  gpiog_crl_mode3,
  gpiog_idr_idr3,
  gpiog_lckr_lck3,
  gpiog_moder_moder3,
  gpiog_odr_odr3,
  gpiog_ospeedr_ospeedr3,
  gpiog_otyper_ot3,
  gpiog_pupdr_pupdr3,
  gpiog_afrl,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crl,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  ((
    Asc3,
    gpiog_ascr_asc3,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 4.",
  Gpiog4,
  peripheral_gpiog_4,
  "GPIO port G pin 4 tokens.",
  Gpiog4Tokens,
  gpiog,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpiog_afrl_afrl4,
  gpiog_brr_br4,
  gpiog_bsrr_br4,
  gpiog_bsrr_bs4,
  gpiog_crl_cnf4,
  gpiog_crl_mode4,
  gpiog_idr_idr4,
  gpiog_lckr_lck4,
  gpiog_moder_moder4,
  gpiog_odr_odr4,
  gpiog_ospeedr_ospeedr4,
  gpiog_otyper_ot4,
  gpiog_pupdr_pupdr4,
  gpiog_afrl,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crl,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  ((
    Asc4,
    gpiog_ascr_asc4,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 5.",
  Gpiog5,
  peripheral_gpiog_5,
  "GPIO port G pin 5 tokens.",
  Gpiog5Tokens,
  gpiog,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpiog_afrl_afrl5,
  gpiog_brr_br5,
  gpiog_bsrr_br5,
  gpiog_bsrr_bs5,
  gpiog_crl_cnf5,
  gpiog_crl_mode5,
  gpiog_idr_idr5,
  gpiog_lckr_lck5,
  gpiog_moder_moder5,
  gpiog_odr_odr5,
  gpiog_ospeedr_ospeedr5,
  gpiog_otyper_ot5,
  gpiog_pupdr_pupdr5,
  gpiog_afrl,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crl,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  ((
    Asc5,
    gpiog_ascr_asc5,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 6.",
  Gpiog6,
  peripheral_gpiog_6,
  "GPIO port G pin 6 tokens.",
  Gpiog6Tokens,
  gpiog,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpiog_afrl_afrl6,
  gpiog_brr_br6,
  gpiog_bsrr_br6,
  gpiog_bsrr_bs6,
  gpiog_crl_cnf6,
  gpiog_crl_mode6,
  gpiog_idr_idr6,
  gpiog_lckr_lck6,
  gpiog_moder_moder6,
  gpiog_odr_odr6,
  gpiog_ospeedr_ospeedr6,
  gpiog_otyper_ot6,
  gpiog_pupdr_pupdr6,
  gpiog_afrl,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crl,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  ((
    Asc6,
    gpiog_ascr_asc6,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 7.",
  Gpiog7,
  peripheral_gpiog_7,
  "GPIO port G pin 7 tokens.",
  Gpiog7Tokens,
  gpiog,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpiog_afrl_afrl7,
  gpiog_brr_br7,
  gpiog_bsrr_br7,
  gpiog_bsrr_bs7,
  gpiog_crl_cnf7,
  gpiog_crl_mode7,
  gpiog_idr_idr7,
  gpiog_lckr_lck7,
  gpiog_moder_moder7,
  gpiog_odr_odr7,
  gpiog_ospeedr_ospeedr7,
  gpiog_otyper_ot7,
  gpiog_pupdr_pupdr7,
  gpiog_afrl,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crl,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  ((
    Asc7,
    gpiog_ascr_asc7,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 8.",
  Gpiog8,
  peripheral_gpiog_8,
  "GPIO port G pin 8 tokens.",
  Gpiog8Tokens,
  gpiog,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpiog_afrh_afrh8,
  gpiog_brr_br8,
  gpiog_bsrr_br8,
  gpiog_bsrr_bs8,
  gpiog_crh_cnf8,
  gpiog_crh_mode8,
  gpiog_idr_idr8,
  gpiog_lckr_lck8,
  gpiog_moder_moder8,
  gpiog_odr_odr8,
  gpiog_ospeedr_ospeedr8,
  gpiog_otyper_ot8,
  gpiog_pupdr_pupdr8,
  gpiog_afrh,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crh,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  ((
    Asc8,
    gpiog_ascr_asc8,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 9.",
  Gpiog9,
  peripheral_gpiog_9,
  "GPIO port G pin 9 tokens.",
  Gpiog9Tokens,
  gpiog,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpiog_afrh_afrh9,
  gpiog_brr_br9,
  gpiog_bsrr_br9,
  gpiog_bsrr_bs9,
  gpiog_crh_cnf9,
  gpiog_crh_mode9,
  gpiog_idr_idr9,
  gpiog_lckr_lck9,
  gpiog_moder_moder9,
  gpiog_odr_odr9,
  gpiog_ospeedr_ospeedr9,
  gpiog_otyper_ot9,
  gpiog_pupdr_pupdr9,
  gpiog_afrh,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crh,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  ((
    Asc9,
    gpiog_ascr_asc9,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 10.",
  Gpiog10,
  peripheral_gpiog_10,
  "GPIO port G pin 10 tokens.",
  Gpiog10Tokens,
  gpiog,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpiog_afrh_afrh10,
  gpiog_brr_br10,
  gpiog_bsrr_br10,
  gpiog_bsrr_bs10,
  gpiog_crh_cnf10,
  gpiog_crh_mode10,
  gpiog_idr_idr10,
  gpiog_lckr_lck10,
  gpiog_moder_moder10,
  gpiog_odr_odr10,
  gpiog_ospeedr_ospeedr10,
  gpiog_otyper_ot10,
  gpiog_pupdr_pupdr10,
  gpiog_afrh,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crh,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  ((
    Asc10,
    gpiog_ascr_asc10,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 11.",
  Gpiog11,
  peripheral_gpiog_11,
  "GPIO port G pin 11 tokens.",
  Gpiog11Tokens,
  gpiog,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpiog_afrh_afrh11,
  gpiog_brr_br11,
  gpiog_bsrr_br11,
  gpiog_bsrr_bs11,
  gpiog_crh_cnf11,
  gpiog_crh_mode11,
  gpiog_idr_idr11,
  gpiog_lckr_lck11,
  gpiog_moder_moder11,
  gpiog_odr_odr11,
  gpiog_ospeedr_ospeedr11,
  gpiog_otyper_ot11,
  gpiog_pupdr_pupdr11,
  gpiog_afrh,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crh,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  ((
    Asc11,
    gpiog_ascr_asc11,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 12.",
  Gpiog12,
  peripheral_gpiog_12,
  "GPIO port G pin 12 tokens.",
  Gpiog12Tokens,
  gpiog,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpiog_afrh_afrh12,
  gpiog_brr_br12,
  gpiog_bsrr_br12,
  gpiog_bsrr_bs12,
  gpiog_crh_cnf12,
  gpiog_crh_mode12,
  gpiog_idr_idr12,
  gpiog_lckr_lck12,
  gpiog_moder_moder12,
  gpiog_odr_odr12,
  gpiog_ospeedr_ospeedr12,
  gpiog_otyper_ot12,
  gpiog_pupdr_pupdr12,
  gpiog_afrh,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crh,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  ((
    Asc12,
    gpiog_ascr_asc12,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 13.",
  Gpiog13,
  peripheral_gpiog_13,
  "GPIO port G pin 13 tokens.",
  Gpiog13Tokens,
  gpiog,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpiog_afrh_afrh13,
  gpiog_brr_br13,
  gpiog_bsrr_br13,
  gpiog_bsrr_bs13,
  gpiog_crh_cnf13,
  gpiog_crh_mode13,
  gpiog_idr_idr13,
  gpiog_lckr_lck13,
  gpiog_moder_moder13,
  gpiog_odr_odr13,
  gpiog_ospeedr_ospeedr13,
  gpiog_otyper_ot13,
  gpiog_pupdr_pupdr13,
  gpiog_afrh,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crh,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  ((
    Asc13,
    gpiog_ascr_asc13,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 14.",
  Gpiog14,
  peripheral_gpiog_14,
  "GPIO port G pin 14 tokens.",
  Gpiog14Tokens,
  gpiog,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpiog_afrh_afrh14,
  gpiog_brr_br14,
  gpiog_bsrr_br14,
  gpiog_bsrr_bs14,
  gpiog_crh_cnf14,
  gpiog_crh_mode14,
  gpiog_idr_idr14,
  gpiog_lckr_lck14,
  gpiog_moder_moder14,
  gpiog_odr_odr14,
  gpiog_ospeedr_ospeedr14,
  gpiog_otyper_ot14,
  gpiog_pupdr_pupdr14,
  gpiog_afrh,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crh,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  ((
    Asc14,
    gpiog_ascr_asc14,
  )),
}

#[cfg(any(feature = "stm32f100", feature = "stm32f101",
          feature = "stm32f102", feature = "stm32f103",
          feature = "stm32f107", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port G pin 15.",
  Gpiog15,
  peripheral_gpiog_15,
  "GPIO port G pin 15 tokens.",
  Gpiog15Tokens,
  gpiog,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpiog_afrh_afrh15,
  gpiog_brr_br15,
  gpiog_bsrr_br15,
  gpiog_bsrr_bs15,
  gpiog_crh_cnf15,
  gpiog_crh_mode15,
  gpiog_idr_idr15,
  gpiog_lckr_lck15,
  gpiog_moder_moder15,
  gpiog_odr_odr15,
  gpiog_ospeedr_ospeedr15,
  gpiog_otyper_ot15,
  gpiog_pupdr_pupdr15,
  gpiog_afrh,
  gpiog_ascr,
  gpiog_brr,
  gpiog_bsrr,
  gpiog_crh,
  gpiog_idr,
  gpiog_lckr,
  gpiog_moder,
  gpiog_odr,
  gpiog_ospeedr,
  gpiog_otyper,
  gpiog_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  ((
    Asc15,
    gpiog_ascr_asc15,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 0.",
  Gpioh0,
  peripheral_gpioh_0,
  "GPIO port H pin 0 tokens.",
  Gpioh0Tokens,
  gpioh,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpioh_afrl_afrl0,
  gpioh_brr_br0,
  gpioh_bsrr_br0,
  gpioh_bsrr_bs0,
  gpioh_crl_cnf0,
  gpioh_crl_mode0,
  gpioh_idr_idr0,
  gpioh_lckr_lck0,
  gpioh_moder_moder0,
  gpioh_odr_odr0,
  gpioh_ospeedr_ospeedr0,
  gpioh_otyper_ot0,
  gpioh_pupdr_pupdr0,
  gpioh_afrl,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crl,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  ((
    Asc0,
    gpioh_ascr_asc0,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 1.",
  Gpioh1,
  peripheral_gpioh_1,
  "GPIO port H pin 1 tokens.",
  Gpioh1Tokens,
  gpioh,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpioh_afrl_afrl1,
  gpioh_brr_br1,
  gpioh_bsrr_br1,
  gpioh_bsrr_bs1,
  gpioh_crl_cnf1,
  gpioh_crl_mode1,
  gpioh_idr_idr1,
  gpioh_lckr_lck1,
  gpioh_moder_moder1,
  gpioh_odr_odr1,
  gpioh_ospeedr_ospeedr1,
  gpioh_otyper_ot1,
  gpioh_pupdr_pupdr1,
  gpioh_afrl,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crl,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  ((
    Asc1,
    gpioh_ascr_asc1,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 2.",
  Gpioh2,
  peripheral_gpioh_2,
  "GPIO port H pin 2 tokens.",
  Gpioh2Tokens,
  gpioh,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpioh_afrl_afrl2,
  gpioh_brr_br2,
  gpioh_bsrr_br2,
  gpioh_bsrr_bs2,
  gpioh_crl_cnf2,
  gpioh_crl_mode2,
  gpioh_idr_idr2,
  gpioh_lckr_lck2,
  gpioh_moder_moder2,
  gpioh_odr_odr2,
  gpioh_ospeedr_ospeedr2,
  gpioh_otyper_ot2,
  gpioh_pupdr_pupdr2,
  gpioh_afrl,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crl,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  ((
    Asc2,
    gpioh_ascr_asc2,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 3.",
  Gpioh3,
  peripheral_gpioh_3,
  "GPIO port H pin 3 tokens.",
  Gpioh3Tokens,
  gpioh,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpioh_afrl_afrl3,
  gpioh_brr_br3,
  gpioh_bsrr_br3,
  gpioh_bsrr_bs3,
  gpioh_crl_cnf3,
  gpioh_crl_mode3,
  gpioh_idr_idr3,
  gpioh_lckr_lck3,
  gpioh_moder_moder3,
  gpioh_odr_odr3,
  gpioh_ospeedr_ospeedr3,
  gpioh_otyper_ot3,
  gpioh_pupdr_pupdr3,
  gpioh_afrl,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crl,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  ((
    Asc3,
    gpioh_ascr_asc3,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 4.",
  Gpioh4,
  peripheral_gpioh_4,
  "GPIO port H pin 4 tokens.",
  Gpioh4Tokens,
  gpioh,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpioh_afrl_afrl4,
  gpioh_brr_br4,
  gpioh_bsrr_br4,
  gpioh_bsrr_bs4,
  gpioh_crl_cnf4,
  gpioh_crl_mode4,
  gpioh_idr_idr4,
  gpioh_lckr_lck4,
  gpioh_moder_moder4,
  gpioh_odr_odr4,
  gpioh_ospeedr_ospeedr4,
  gpioh_otyper_ot4,
  gpioh_pupdr_pupdr4,
  gpioh_afrl,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crl,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  ((
    Asc4,
    gpioh_ascr_asc4,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 5.",
  Gpioh5,
  peripheral_gpioh_5,
  "GPIO port H pin 5 tokens.",
  Gpioh5Tokens,
  gpioh,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpioh_afrl_afrl5,
  gpioh_brr_br5,
  gpioh_bsrr_br5,
  gpioh_bsrr_bs5,
  gpioh_crl_cnf5,
  gpioh_crl_mode5,
  gpioh_idr_idr5,
  gpioh_lckr_lck5,
  gpioh_moder_moder5,
  gpioh_odr_odr5,
  gpioh_ospeedr_ospeedr5,
  gpioh_otyper_ot5,
  gpioh_pupdr_pupdr5,
  gpioh_afrl,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crl,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  ((
    Asc5,
    gpioh_ascr_asc5,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 6.",
  Gpioh6,
  peripheral_gpioh_6,
  "GPIO port H pin 6 tokens.",
  Gpioh6Tokens,
  gpioh,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpioh_afrl_afrl6,
  gpioh_brr_br6,
  gpioh_bsrr_br6,
  gpioh_bsrr_bs6,
  gpioh_crl_cnf6,
  gpioh_crl_mode6,
  gpioh_idr_idr6,
  gpioh_lckr_lck6,
  gpioh_moder_moder6,
  gpioh_odr_odr6,
  gpioh_ospeedr_ospeedr6,
  gpioh_otyper_ot6,
  gpioh_pupdr_pupdr6,
  gpioh_afrl,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crl,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  ((
    Asc6,
    gpioh_ascr_asc6,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 7.",
  Gpioh7,
  peripheral_gpioh_7,
  "GPIO port H pin 7 tokens.",
  Gpioh7Tokens,
  gpioh,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpioh_afrl_afrl7,
  gpioh_brr_br7,
  gpioh_bsrr_br7,
  gpioh_bsrr_bs7,
  gpioh_crl_cnf7,
  gpioh_crl_mode7,
  gpioh_idr_idr7,
  gpioh_lckr_lck7,
  gpioh_moder_moder7,
  gpioh_odr_odr7,
  gpioh_ospeedr_ospeedr7,
  gpioh_otyper_ot7,
  gpioh_pupdr_pupdr7,
  gpioh_afrl,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crl,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  ((
    Asc7,
    gpioh_ascr_asc7,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 8.",
  Gpioh8,
  peripheral_gpioh_8,
  "GPIO port H pin 8 tokens.",
  Gpioh8Tokens,
  gpioh,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpioh_afrh_afrh8,
  gpioh_brr_br8,
  gpioh_bsrr_br8,
  gpioh_bsrr_bs8,
  gpioh_crh_cnf8,
  gpioh_crh_mode8,
  gpioh_idr_idr8,
  gpioh_lckr_lck8,
  gpioh_moder_moder8,
  gpioh_odr_odr8,
  gpioh_ospeedr_ospeedr8,
  gpioh_otyper_ot8,
  gpioh_pupdr_pupdr8,
  gpioh_afrh,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crh,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  ((
    Asc8,
    gpioh_ascr_asc8,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 9.",
  Gpioh9,
  peripheral_gpioh_9,
  "GPIO port H pin 9 tokens.",
  Gpioh9Tokens,
  gpioh,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpioh_afrh_afrh9,
  gpioh_brr_br9,
  gpioh_bsrr_br9,
  gpioh_bsrr_bs9,
  gpioh_crh_cnf9,
  gpioh_crh_mode9,
  gpioh_idr_idr9,
  gpioh_lckr_lck9,
  gpioh_moder_moder9,
  gpioh_odr_odr9,
  gpioh_ospeedr_ospeedr9,
  gpioh_otyper_ot9,
  gpioh_pupdr_pupdr9,
  gpioh_afrh,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crh,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  ((
    Asc9,
    gpioh_ascr_asc9,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 10.",
  Gpioh10,
  peripheral_gpioh_10,
  "GPIO port H pin 10 tokens.",
  Gpioh10Tokens,
  gpioh,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpioh_afrh_afrh10,
  gpioh_brr_br10,
  gpioh_bsrr_br10,
  gpioh_bsrr_bs10,
  gpioh_crh_cnf10,
  gpioh_crh_mode10,
  gpioh_idr_idr10,
  gpioh_lckr_lck10,
  gpioh_moder_moder10,
  gpioh_odr_odr10,
  gpioh_ospeedr_ospeedr10,
  gpioh_otyper_ot10,
  gpioh_pupdr_pupdr10,
  gpioh_afrh,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crh,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  ((
    Asc10,
    gpioh_ascr_asc10,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 11.",
  Gpioh11,
  peripheral_gpioh_11,
  "GPIO port H pin 11 tokens.",
  Gpioh11Tokens,
  gpioh,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpioh_afrh_afrh11,
  gpioh_brr_br11,
  gpioh_bsrr_br11,
  gpioh_bsrr_bs11,
  gpioh_crh_cnf11,
  gpioh_crh_mode11,
  gpioh_idr_idr11,
  gpioh_lckr_lck11,
  gpioh_moder_moder11,
  gpioh_odr_odr11,
  gpioh_ospeedr_ospeedr11,
  gpioh_otyper_ot11,
  gpioh_pupdr_pupdr11,
  gpioh_afrh,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crh,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  ((
    Asc11,
    gpioh_ascr_asc11,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 12.",
  Gpioh12,
  peripheral_gpioh_12,
  "GPIO port H pin 12 tokens.",
  Gpioh12Tokens,
  gpioh,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpioh_afrh_afrh12,
  gpioh_brr_br12,
  gpioh_bsrr_br12,
  gpioh_bsrr_bs12,
  gpioh_crh_cnf12,
  gpioh_crh_mode12,
  gpioh_idr_idr12,
  gpioh_lckr_lck12,
  gpioh_moder_moder12,
  gpioh_odr_odr12,
  gpioh_ospeedr_ospeedr12,
  gpioh_otyper_ot12,
  gpioh_pupdr_pupdr12,
  gpioh_afrh,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crh,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  ((
    Asc12,
    gpioh_ascr_asc12,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 13.",
  Gpioh13,
  peripheral_gpioh_13,
  "GPIO port H pin 13 tokens.",
  Gpioh13Tokens,
  gpioh,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpioh_afrh_afrh13,
  gpioh_brr_br13,
  gpioh_bsrr_br13,
  gpioh_bsrr_bs13,
  gpioh_crh_cnf13,
  gpioh_crh_mode13,
  gpioh_idr_idr13,
  gpioh_lckr_lck13,
  gpioh_moder_moder13,
  gpioh_odr_odr13,
  gpioh_ospeedr_ospeedr13,
  gpioh_otyper_ot13,
  gpioh_pupdr_pupdr13,
  gpioh_afrh,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crh,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  ((
    Asc13,
    gpioh_ascr_asc13,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 14.",
  Gpioh14,
  peripheral_gpioh_14,
  "GPIO port H pin 14 tokens.",
  Gpioh14Tokens,
  gpioh,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpioh_afrh_afrh14,
  gpioh_brr_br14,
  gpioh_bsrr_br14,
  gpioh_bsrr_bs14,
  gpioh_crh_cnf14,
  gpioh_crh_mode14,
  gpioh_idr_idr14,
  gpioh_lckr_lck14,
  gpioh_moder_moder14,
  gpioh_odr_odr14,
  gpioh_ospeedr_ospeedr14,
  gpioh_otyper_ot14,
  gpioh_pupdr_pupdr14,
  gpioh_afrh,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crh,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  ((
    Asc14,
    gpioh_ascr_asc14,
  )),
}

#[cfg(any(feature = "stm32l4x1", feature = "stm32l4x2",
          feature = "stm32l4x3", feature = "stm32l4x5",
          feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port H pin 15.",
  Gpioh15,
  peripheral_gpioh_15,
  "GPIO port H pin 15 tokens.",
  Gpioh15Tokens,
  gpioh,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpioh_afrh_afrh15,
  gpioh_brr_br15,
  gpioh_bsrr_br15,
  gpioh_bsrr_bs15,
  gpioh_crh_cnf15,
  gpioh_crh_mode15,
  gpioh_idr_idr15,
  gpioh_lckr_lck15,
  gpioh_moder_moder15,
  gpioh_odr_odr15,
  gpioh_ospeedr_ospeedr15,
  gpioh_otyper_ot15,
  gpioh_pupdr_pupdr15,
  gpioh_afrh,
  gpioh_ascr,
  gpioh_brr,
  gpioh_bsrr,
  gpioh_crh,
  gpioh_idr,
  gpioh_lckr,
  gpioh_moder,
  gpioh_odr,
  gpioh_ospeedr,
  gpioh_otyper,
  gpioh_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  ((
    Asc15,
    gpioh_ascr_asc15,
  )),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 0.",
  Gpioi0,
  peripheral_gpioi_0,
  "GPIO port I pin 0 tokens.",
  Gpioi0Tokens,
  gpioi,
  afrl,
  crl,
  Afrl0,
  Br0,
  Bs0,
  Cnf0,
  Mode0,
  Idr0,
  Lck0,
  Moder0,
  Odr0,
  Ospeedr0,
  Ot0,
  Pupdr0,
  gpioi_afrl_afrl0,
  gpioi_brr_br0,
  gpioi_bsrr_br0,
  gpioi_bsrr_bs0,
  gpioi_crl_cnf0,
  gpioi_crl_mode0,
  gpioi_idr_idr0,
  gpioi_lckr_lck0,
  gpioi_moder_moder0,
  gpioi_odr_odr0,
  gpioi_ospeedr_ospeedr0,
  gpioi_otyper_ot0,
  gpioi_pupdr_pupdr0,
  gpioi_afrl,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crl,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrl0,
  asc0,
  br0,
  bs0,
  cnf0,
  mode0,
  idr0,
  lck0,
  moder0,
  odr0,
  ospeedr0,
  ot0,
  pupdr0,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 1.",
  Gpioi1,
  peripheral_gpioi_1,
  "GPIO port I pin 1 tokens.",
  Gpioi1Tokens,
  gpioi,
  afrl,
  crl,
  Afrl1,
  Br1,
  Bs1,
  Cnf1,
  Mode1,
  Idr1,
  Lck1,
  Moder1,
  Odr1,
  Ospeedr1,
  Ot1,
  Pupdr1,
  gpioi_afrl_afrl1,
  gpioi_brr_br1,
  gpioi_bsrr_br1,
  gpioi_bsrr_bs1,
  gpioi_crl_cnf1,
  gpioi_crl_mode1,
  gpioi_idr_idr1,
  gpioi_lckr_lck1,
  gpioi_moder_moder1,
  gpioi_odr_odr1,
  gpioi_ospeedr_ospeedr1,
  gpioi_otyper_ot1,
  gpioi_pupdr_pupdr1,
  gpioi_afrl,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crl,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrl1,
  asc1,
  br1,
  bs1,
  cnf1,
  mode1,
  idr1,
  lck1,
  moder1,
  odr1,
  ospeedr1,
  ot1,
  pupdr1,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 2.",
  Gpioi2,
  peripheral_gpioi_2,
  "GPIO port I pin 2 tokens.",
  Gpioi2Tokens,
  gpioi,
  afrl,
  crl,
  Afrl2,
  Br2,
  Bs2,
  Cnf2,
  Mode2,
  Idr2,
  Lck2,
  Moder2,
  Odr2,
  Ospeedr2,
  Ot2,
  Pupdr2,
  gpioi_afrl_afrl2,
  gpioi_brr_br2,
  gpioi_bsrr_br2,
  gpioi_bsrr_bs2,
  gpioi_crl_cnf2,
  gpioi_crl_mode2,
  gpioi_idr_idr2,
  gpioi_lckr_lck2,
  gpioi_moder_moder2,
  gpioi_odr_odr2,
  gpioi_ospeedr_ospeedr2,
  gpioi_otyper_ot2,
  gpioi_pupdr_pupdr2,
  gpioi_afrl,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crl,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrl2,
  asc2,
  br2,
  bs2,
  cnf2,
  mode2,
  idr2,
  lck2,
  moder2,
  odr2,
  ospeedr2,
  ot2,
  pupdr2,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 3.",
  Gpioi3,
  peripheral_gpioi_3,
  "GPIO port I pin 3 tokens.",
  Gpioi3Tokens,
  gpioi,
  afrl,
  crl,
  Afrl3,
  Br3,
  Bs3,
  Cnf3,
  Mode3,
  Idr3,
  Lck3,
  Moder3,
  Odr3,
  Ospeedr3,
  Ot3,
  Pupdr3,
  gpioi_afrl_afrl3,
  gpioi_brr_br3,
  gpioi_bsrr_br3,
  gpioi_bsrr_bs3,
  gpioi_crl_cnf3,
  gpioi_crl_mode3,
  gpioi_idr_idr3,
  gpioi_lckr_lck3,
  gpioi_moder_moder3,
  gpioi_odr_odr3,
  gpioi_ospeedr_ospeedr3,
  gpioi_otyper_ot3,
  gpioi_pupdr_pupdr3,
  gpioi_afrl,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crl,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrl3,
  asc3,
  br3,
  bs3,
  cnf3,
  mode3,
  idr3,
  lck3,
  moder3,
  odr3,
  ospeedr3,
  ot3,
  pupdr3,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 4.",
  Gpioi4,
  peripheral_gpioi_4,
  "GPIO port I pin 4 tokens.",
  Gpioi4Tokens,
  gpioi,
  afrl,
  crl,
  Afrl4,
  Br4,
  Bs4,
  Cnf4,
  Mode4,
  Idr4,
  Lck4,
  Moder4,
  Odr4,
  Ospeedr4,
  Ot4,
  Pupdr4,
  gpioi_afrl_afrl4,
  gpioi_brr_br4,
  gpioi_bsrr_br4,
  gpioi_bsrr_bs4,
  gpioi_crl_cnf4,
  gpioi_crl_mode4,
  gpioi_idr_idr4,
  gpioi_lckr_lck4,
  gpioi_moder_moder4,
  gpioi_odr_odr4,
  gpioi_ospeedr_ospeedr4,
  gpioi_otyper_ot4,
  gpioi_pupdr_pupdr4,
  gpioi_afrl,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crl,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrl4,
  asc4,
  br4,
  bs4,
  cnf4,
  mode4,
  idr4,
  lck4,
  moder4,
  odr4,
  ospeedr4,
  ot4,
  pupdr4,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 5.",
  Gpioi5,
  peripheral_gpioi_5,
  "GPIO port I pin 5 tokens.",
  Gpioi5Tokens,
  gpioi,
  afrl,
  crl,
  Afrl5,
  Br5,
  Bs5,
  Cnf5,
  Mode5,
  Idr5,
  Lck5,
  Moder5,
  Odr5,
  Ospeedr5,
  Ot5,
  Pupdr5,
  gpioi_afrl_afrl5,
  gpioi_brr_br5,
  gpioi_bsrr_br5,
  gpioi_bsrr_bs5,
  gpioi_crl_cnf5,
  gpioi_crl_mode5,
  gpioi_idr_idr5,
  gpioi_lckr_lck5,
  gpioi_moder_moder5,
  gpioi_odr_odr5,
  gpioi_ospeedr_ospeedr5,
  gpioi_otyper_ot5,
  gpioi_pupdr_pupdr5,
  gpioi_afrl,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crl,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrl5,
  asc5,
  br5,
  bs5,
  cnf5,
  mode5,
  idr5,
  lck5,
  moder5,
  odr5,
  ospeedr5,
  ot5,
  pupdr5,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 6.",
  Gpioi6,
  peripheral_gpioi_6,
  "GPIO port I pin 6 tokens.",
  Gpioi6Tokens,
  gpioi,
  afrl,
  crl,
  Afrl6,
  Br6,
  Bs6,
  Cnf6,
  Mode6,
  Idr6,
  Lck6,
  Moder6,
  Odr6,
  Ospeedr6,
  Ot6,
  Pupdr6,
  gpioi_afrl_afrl6,
  gpioi_brr_br6,
  gpioi_bsrr_br6,
  gpioi_bsrr_bs6,
  gpioi_crl_cnf6,
  gpioi_crl_mode6,
  gpioi_idr_idr6,
  gpioi_lckr_lck6,
  gpioi_moder_moder6,
  gpioi_odr_odr6,
  gpioi_ospeedr_ospeedr6,
  gpioi_otyper_ot6,
  gpioi_pupdr_pupdr6,
  gpioi_afrl,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crl,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrl6,
  asc6,
  br6,
  bs6,
  cnf6,
  mode6,
  idr6,
  lck6,
  moder6,
  odr6,
  ospeedr6,
  ot6,
  pupdr6,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 7.",
  Gpioi7,
  peripheral_gpioi_7,
  "GPIO port I pin 7 tokens.",
  Gpioi7Tokens,
  gpioi,
  afrl,
  crl,
  Afrl7,
  Br7,
  Bs7,
  Cnf7,
  Mode7,
  Idr7,
  Lck7,
  Moder7,
  Odr7,
  Ospeedr7,
  Ot7,
  Pupdr7,
  gpioi_afrl_afrl7,
  gpioi_brr_br7,
  gpioi_bsrr_br7,
  gpioi_bsrr_bs7,
  gpioi_crl_cnf7,
  gpioi_crl_mode7,
  gpioi_idr_idr7,
  gpioi_lckr_lck7,
  gpioi_moder_moder7,
  gpioi_odr_odr7,
  gpioi_ospeedr_ospeedr7,
  gpioi_otyper_ot7,
  gpioi_pupdr_pupdr7,
  gpioi_afrl,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crl,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrl7,
  asc7,
  br7,
  bs7,
  cnf7,
  mode7,
  idr7,
  lck7,
  moder7,
  odr7,
  ospeedr7,
  ot7,
  pupdr7,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 8.",
  Gpioi8,
  peripheral_gpioi_8,
  "GPIO port I pin 8 tokens.",
  Gpioi8Tokens,
  gpioi,
  afrh,
  crh,
  Afrh8,
  Br8,
  Bs8,
  Cnf8,
  Mode8,
  Idr8,
  Lck8,
  Moder8,
  Odr8,
  Ospeedr8,
  Ot8,
  Pupdr8,
  gpioi_afrh_afrh8,
  gpioi_brr_br8,
  gpioi_bsrr_br8,
  gpioi_bsrr_bs8,
  gpioi_crh_cnf8,
  gpioi_crh_mode8,
  gpioi_idr_idr8,
  gpioi_lckr_lck8,
  gpioi_moder_moder8,
  gpioi_odr_odr8,
  gpioi_ospeedr_ospeedr8,
  gpioi_otyper_ot8,
  gpioi_pupdr_pupdr8,
  gpioi_afrh,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crh,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrh8,
  asc8,
  br8,
  bs8,
  cnf8,
  mode8,
  idr8,
  lck8,
  moder8,
  odr8,
  ospeedr8,
  ot8,
  pupdr8,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 9.",
  Gpioi9,
  peripheral_gpioi_9,
  "GPIO port I pin 9 tokens.",
  Gpioi9Tokens,
  gpioi,
  afrh,
  crh,
  Afrh9,
  Br9,
  Bs9,
  Cnf9,
  Mode9,
  Idr9,
  Lck9,
  Moder9,
  Odr9,
  Ospeedr9,
  Ot9,
  Pupdr9,
  gpioi_afrh_afrh9,
  gpioi_brr_br9,
  gpioi_bsrr_br9,
  gpioi_bsrr_bs9,
  gpioi_crh_cnf9,
  gpioi_crh_mode9,
  gpioi_idr_idr9,
  gpioi_lckr_lck9,
  gpioi_moder_moder9,
  gpioi_odr_odr9,
  gpioi_ospeedr_ospeedr9,
  gpioi_otyper_ot9,
  gpioi_pupdr_pupdr9,
  gpioi_afrh,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crh,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrh9,
  asc9,
  br9,
  bs9,
  cnf9,
  mode9,
  idr9,
  lck9,
  moder9,
  odr9,
  ospeedr9,
  ot9,
  pupdr9,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 10.",
  Gpioi10,
  peripheral_gpioi_10,
  "GPIO port I pin 10 tokens.",
  Gpioi10Tokens,
  gpioi,
  afrh,
  crh,
  Afrh10,
  Br10,
  Bs10,
  Cnf10,
  Mode10,
  Idr10,
  Lck10,
  Moder10,
  Odr10,
  Ospeedr10,
  Ot10,
  Pupdr10,
  gpioi_afrh_afrh10,
  gpioi_brr_br10,
  gpioi_bsrr_br10,
  gpioi_bsrr_bs10,
  gpioi_crh_cnf10,
  gpioi_crh_mode10,
  gpioi_idr_idr10,
  gpioi_lckr_lck10,
  gpioi_moder_moder10,
  gpioi_odr_odr10,
  gpioi_ospeedr_ospeedr10,
  gpioi_otyper_ot10,
  gpioi_pupdr_pupdr10,
  gpioi_afrh,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crh,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrh10,
  asc10,
  br10,
  bs10,
  cnf10,
  mode10,
  idr10,
  lck10,
  moder10,
  odr10,
  ospeedr10,
  ot10,
  pupdr10,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 11.",
  Gpioi11,
  peripheral_gpioi_11,
  "GPIO port I pin 11 tokens.",
  Gpioi11Tokens,
  gpioi,
  afrh,
  crh,
  Afrh11,
  Br11,
  Bs11,
  Cnf11,
  Mode11,
  Idr11,
  Lck11,
  Moder11,
  Odr11,
  Ospeedr11,
  Ot11,
  Pupdr11,
  gpioi_afrh_afrh11,
  gpioi_brr_br11,
  gpioi_bsrr_br11,
  gpioi_bsrr_bs11,
  gpioi_crh_cnf11,
  gpioi_crh_mode11,
  gpioi_idr_idr11,
  gpioi_lckr_lck11,
  gpioi_moder_moder11,
  gpioi_odr_odr11,
  gpioi_ospeedr_ospeedr11,
  gpioi_otyper_ot11,
  gpioi_pupdr_pupdr11,
  gpioi_afrh,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crh,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrh11,
  asc11,
  br11,
  bs11,
  cnf11,
  mode11,
  idr11,
  lck11,
  moder11,
  odr11,
  ospeedr11,
  ot11,
  pupdr11,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 12.",
  Gpioi12,
  peripheral_gpioi_12,
  "GPIO port I pin 12 tokens.",
  Gpioi12Tokens,
  gpioi,
  afrh,
  crh,
  Afrh12,
  Br12,
  Bs12,
  Cnf12,
  Mode12,
  Idr12,
  Lck12,
  Moder12,
  Odr12,
  Ospeedr12,
  Ot12,
  Pupdr12,
  gpioi_afrh_afrh12,
  gpioi_brr_br12,
  gpioi_bsrr_br12,
  gpioi_bsrr_bs12,
  gpioi_crh_cnf12,
  gpioi_crh_mode12,
  gpioi_idr_idr12,
  gpioi_lckr_lck12,
  gpioi_moder_moder12,
  gpioi_odr_odr12,
  gpioi_ospeedr_ospeedr12,
  gpioi_otyper_ot12,
  gpioi_pupdr_pupdr12,
  gpioi_afrh,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crh,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrh12,
  asc12,
  br12,
  bs12,
  cnf12,
  mode12,
  idr12,
  lck12,
  moder12,
  odr12,
  ospeedr12,
  ot12,
  pupdr12,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 13.",
  Gpioi13,
  peripheral_gpioi_13,
  "GPIO port I pin 13 tokens.",
  Gpioi13Tokens,
  gpioi,
  afrh,
  crh,
  Afrh13,
  Br13,
  Bs13,
  Cnf13,
  Mode13,
  Idr13,
  Lck13,
  Moder13,
  Odr13,
  Ospeedr13,
  Ot13,
  Pupdr13,
  gpioi_afrh_afrh13,
  gpioi_brr_br13,
  gpioi_bsrr_br13,
  gpioi_bsrr_bs13,
  gpioi_crh_cnf13,
  gpioi_crh_mode13,
  gpioi_idr_idr13,
  gpioi_lckr_lck13,
  gpioi_moder_moder13,
  gpioi_odr_odr13,
  gpioi_ospeedr_ospeedr13,
  gpioi_otyper_ot13,
  gpioi_pupdr_pupdr13,
  gpioi_afrh,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crh,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrh13,
  asc13,
  br13,
  bs13,
  cnf13,
  mode13,
  idr13,
  lck13,
  moder13,
  odr13,
  ospeedr13,
  ot13,
  pupdr13,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 14.",
  Gpioi14,
  peripheral_gpioi_14,
  "GPIO port I pin 14 tokens.",
  Gpioi14Tokens,
  gpioi,
  afrh,
  crh,
  Afrh14,
  Br14,
  Bs14,
  Cnf14,
  Mode14,
  Idr14,
  Lck14,
  Moder14,
  Odr14,
  Ospeedr14,
  Ot14,
  Pupdr14,
  gpioi_afrh_afrh14,
  gpioi_brr_br14,
  gpioi_bsrr_br14,
  gpioi_bsrr_bs14,
  gpioi_crh_cnf14,
  gpioi_crh_mode14,
  gpioi_idr_idr14,
  gpioi_lckr_lck14,
  gpioi_moder_moder14,
  gpioi_odr_odr14,
  gpioi_ospeedr_ospeedr14,
  gpioi_otyper_ot14,
  gpioi_pupdr_pupdr14,
  gpioi_afrh,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crh,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrh14,
  asc14,
  br14,
  bs14,
  cnf14,
  mode14,
  idr14,
  lck14,
  moder14,
  odr14,
  ospeedr14,
  ot14,
  pupdr14,
  (),
}

#[cfg(any(feature = "stm32l4x6"))]
gpio_pin! {
  "GPIO port I pin 15.",
  Gpioi15,
  peripheral_gpioi_15,
  "GPIO port I pin 15 tokens.",
  Gpioi15Tokens,
  gpioi,
  afrh,
  crh,
  Afrh15,
  Br15,
  Bs15,
  Cnf15,
  Mode15,
  Idr15,
  Lck15,
  Moder15,
  Odr15,
  Ospeedr15,
  Ot15,
  Pupdr15,
  gpioi_afrh_afrh15,
  gpioi_brr_br15,
  gpioi_bsrr_br15,
  gpioi_bsrr_bs15,
  gpioi_crh_cnf15,
  gpioi_crh_mode15,
  gpioi_idr_idr15,
  gpioi_lckr_lck15,
  gpioi_moder_moder15,
  gpioi_odr_odr15,
  gpioi_ospeedr_ospeedr15,
  gpioi_otyper_ot15,
  gpioi_pupdr_pupdr15,
  gpioi_afrh,
  gpioi_ascr,
  gpioi_brr,
  gpioi_bsrr,
  gpioi_crh,
  gpioi_idr,
  gpioi_lckr,
  gpioi_moder,
  gpioi_odr,
  gpioi_ospeedr,
  gpioi_otyper,
  gpioi_pupdr,
  afrh15,
  asc15,
  br15,
  bs15,
  cnf15,
  mode15,
  idr15,
  lck15,
  moder15,
  odr15,
  ospeedr15,
  ot15,
  pupdr15,
  (),
}