#[doc = r"Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r"Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::CPUEMR2 {
#[doc = r"Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
self.register.set(f(&R { bits }, &mut W { bits }).bits);
}
#[doc = r"Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r"Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
self.register.set(
f(&mut W {
bits: Self::reset_value(),
})
.bits,
);
}
#[doc = r"Reset value of the register"]
#[inline(always)]
pub const fn reset_value() -> u32 {
0
}
#[doc = r"Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
#[doc = r"Value of the field"]
pub struct MR32R {
bits: bool,
}
impl MR32R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR32W<'a> {
w: &'a mut W,
}
impl<'a> _MR32W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 0);
self.w.bits |= ((value as u32) & 0x01) << 0;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR33R {
bits: bool,
}
impl MR33R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR33W<'a> {
w: &'a mut W,
}
impl<'a> _MR33W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 1);
self.w.bits |= ((value as u32) & 0x01) << 1;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR34R {
bits: bool,
}
impl MR34R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR34W<'a> {
w: &'a mut W,
}
impl<'a> _MR34W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 2);
self.w.bits |= ((value as u32) & 0x01) << 2;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR35R {
bits: bool,
}
impl MR35R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR35W<'a> {
w: &'a mut W,
}
impl<'a> _MR35W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 3);
self.w.bits |= ((value as u32) & 0x01) << 3;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR36R {
bits: bool,
}
impl MR36R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR36W<'a> {
w: &'a mut W,
}
impl<'a> _MR36W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 4);
self.w.bits |= ((value as u32) & 0x01) << 4;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR37R {
bits: bool,
}
impl MR37R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR37W<'a> {
w: &'a mut W,
}
impl<'a> _MR37W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 5);
self.w.bits |= ((value as u32) & 0x01) << 5;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR38R {
bits: bool,
}
impl MR38R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR38W<'a> {
w: &'a mut W,
}
impl<'a> _MR38W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 6);
self.w.bits |= ((value as u32) & 0x01) << 6;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR39R {
bits: bool,
}
impl MR39R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR39W<'a> {
w: &'a mut W,
}
impl<'a> _MR39W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 7);
self.w.bits |= ((value as u32) & 0x01) << 7;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR40R {
bits: bool,
}
impl MR40R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR40W<'a> {
w: &'a mut W,
}
impl<'a> _MR40W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 8);
self.w.bits |= ((value as u32) & 0x01) << 8;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR41R {
bits: bool,
}
impl MR41R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR41W<'a> {
w: &'a mut W,
}
impl<'a> _MR41W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 9);
self.w.bits |= ((value as u32) & 0x01) << 9;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR42R {
bits: bool,
}
impl MR42R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR42W<'a> {
w: &'a mut W,
}
impl<'a> _MR42W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 10);
self.w.bits |= ((value as u32) & 0x01) << 10;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR43R {
bits: bool,
}
impl MR43R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR43W<'a> {
w: &'a mut W,
}
impl<'a> _MR43W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 11);
self.w.bits |= ((value as u32) & 0x01) << 11;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR44R {
bits: bool,
}
impl MR44R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR44W<'a> {
w: &'a mut W,
}
impl<'a> _MR44W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 12);
self.w.bits |= ((value as u32) & 0x01) << 12;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR46R {
bits: bool,
}
impl MR46R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR46W<'a> {
w: &'a mut W,
}
impl<'a> _MR46W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 14);
self.w.bits |= ((value as u32) & 0x01) << 14;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR47R {
bits: bool,
}
impl MR47R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR47W<'a> {
w: &'a mut W,
}
impl<'a> _MR47W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 15);
self.w.bits |= ((value as u32) & 0x01) << 15;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR48R {
bits: bool,
}
impl MR48R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR48W<'a> {
w: &'a mut W,
}
impl<'a> _MR48W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 16);
self.w.bits |= ((value as u32) & 0x01) << 16;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR49R {
bits: bool,
}
impl MR49R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR49W<'a> {
w: &'a mut W,
}
impl<'a> _MR49W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 17);
self.w.bits |= ((value as u32) & 0x01) << 17;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR50R {
bits: bool,
}
impl MR50R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR50W<'a> {
w: &'a mut W,
}
impl<'a> _MR50W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 18);
self.w.bits |= ((value as u32) & 0x01) << 18;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR51R {
bits: bool,
}
impl MR51R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR51W<'a> {
w: &'a mut W,
}
impl<'a> _MR51W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 19);
self.w.bits |= ((value as u32) & 0x01) << 19;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR52R {
bits: bool,
}
impl MR52R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR52W<'a> {
w: &'a mut W,
}
impl<'a> _MR52W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 20);
self.w.bits |= ((value as u32) & 0x01) << 20;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR53R {
bits: bool,
}
impl MR53R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR53W<'a> {
w: &'a mut W,
}
impl<'a> _MR53W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 21);
self.w.bits |= ((value as u32) & 0x01) << 21;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR54R {
bits: bool,
}
impl MR54R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR54W<'a> {
w: &'a mut W,
}
impl<'a> _MR54W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 22);
self.w.bits |= ((value as u32) & 0x01) << 22;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR55R {
bits: bool,
}
impl MR55R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR55W<'a> {
w: &'a mut W,
}
impl<'a> _MR55W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 23);
self.w.bits |= ((value as u32) & 0x01) << 23;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR56R {
bits: bool,
}
impl MR56R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR56W<'a> {
w: &'a mut W,
}
impl<'a> _MR56W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 24);
self.w.bits |= ((value as u32) & 0x01) << 24;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR57R {
bits: bool,
}
impl MR57R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR57W<'a> {
w: &'a mut W,
}
impl<'a> _MR57W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 25);
self.w.bits |= ((value as u32) & 0x01) << 25;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR58R {
bits: bool,
}
impl MR58R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR58W<'a> {
w: &'a mut W,
}
impl<'a> _MR58W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 26);
self.w.bits |= ((value as u32) & 0x01) << 26;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR59R {
bits: bool,
}
impl MR59R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR59W<'a> {
w: &'a mut W,
}
impl<'a> _MR59W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 27);
self.w.bits |= ((value as u32) & 0x01) << 27;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR60R {
bits: bool,
}
impl MR60R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR60W<'a> {
w: &'a mut W,
}
impl<'a> _MR60W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 28);
self.w.bits |= ((value as u32) & 0x01) << 28;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR61R {
bits: bool,
}
impl MR61R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR61W<'a> {
w: &'a mut W,
}
impl<'a> _MR61W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 29);
self.w.bits |= ((value as u32) & 0x01) << 29;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR62R {
bits: bool,
}
impl MR62R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR62W<'a> {
w: &'a mut W,
}
impl<'a> _MR62W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 30);
self.w.bits |= ((value as u32) & 0x01) << 30;
self.w
}
}
#[doc = r"Value of the field"]
pub struct MR63R {
bits: bool,
}
impl MR63R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _MR63W<'a> {
w: &'a mut W,
}
impl<'a> _MR63W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 31);
self.w.bits |= ((value as u32) & 0x01) << 31;
self.w
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 0 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr32(&self) -> MR32R {
let bits = ((self.bits >> 0) & 0x01) != 0;
MR32R { bits }
}
#[doc = "Bit 1 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr33(&self) -> MR33R {
let bits = ((self.bits >> 1) & 0x01) != 0;
MR33R { bits }
}
#[doc = "Bit 2 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr34(&self) -> MR34R {
let bits = ((self.bits >> 2) & 0x01) != 0;
MR34R { bits }
}
#[doc = "Bit 3 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr35(&self) -> MR35R {
let bits = ((self.bits >> 3) & 0x01) != 0;
MR35R { bits }
}
#[doc = "Bit 4 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr36(&self) -> MR36R {
let bits = ((self.bits >> 4) & 0x01) != 0;
MR36R { bits }
}
#[doc = "Bit 5 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr37(&self) -> MR37R {
let bits = ((self.bits >> 5) & 0x01) != 0;
MR37R { bits }
}
#[doc = "Bit 6 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr38(&self) -> MR38R {
let bits = ((self.bits >> 6) & 0x01) != 0;
MR38R { bits }
}
#[doc = "Bit 7 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr39(&self) -> MR39R {
let bits = ((self.bits >> 7) & 0x01) != 0;
MR39R { bits }
}
#[doc = "Bit 8 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr40(&self) -> MR40R {
let bits = ((self.bits >> 8) & 0x01) != 0;
MR40R { bits }
}
#[doc = "Bit 9 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr41(&self) -> MR41R {
let bits = ((self.bits >> 9) & 0x01) != 0;
MR41R { bits }
}
#[doc = "Bit 10 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr42(&self) -> MR42R {
let bits = ((self.bits >> 10) & 0x01) != 0;
MR42R { bits }
}
#[doc = "Bit 11 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr43(&self) -> MR43R {
let bits = ((self.bits >> 11) & 0x01) != 0;
MR43R { bits }
}
#[doc = "Bit 12 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr44(&self) -> MR44R {
let bits = ((self.bits >> 12) & 0x01) != 0;
MR44R { bits }
}
#[doc = "Bit 14 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr46(&self) -> MR46R {
let bits = ((self.bits >> 14) & 0x01) != 0;
MR46R { bits }
}
#[doc = "Bit 15 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr47(&self) -> MR47R {
let bits = ((self.bits >> 15) & 0x01) != 0;
MR47R { bits }
}
#[doc = "Bit 16 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr48(&self) -> MR48R {
let bits = ((self.bits >> 16) & 0x01) != 0;
MR48R { bits }
}
#[doc = "Bit 17 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr49(&self) -> MR49R {
let bits = ((self.bits >> 17) & 0x01) != 0;
MR49R { bits }
}
#[doc = "Bit 18 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr50(&self) -> MR50R {
let bits = ((self.bits >> 18) & 0x01) != 0;
MR50R { bits }
}
#[doc = "Bit 19 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr51(&self) -> MR51R {
let bits = ((self.bits >> 19) & 0x01) != 0;
MR51R { bits }
}
#[doc = "Bit 20 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr52(&self) -> MR52R {
let bits = ((self.bits >> 20) & 0x01) != 0;
MR52R { bits }
}
#[doc = "Bit 21 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr53(&self) -> MR53R {
let bits = ((self.bits >> 21) & 0x01) != 0;
MR53R { bits }
}
#[doc = "Bit 22 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr54(&self) -> MR54R {
let bits = ((self.bits >> 22) & 0x01) != 0;
MR54R { bits }
}
#[doc = "Bit 23 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr55(&self) -> MR55R {
let bits = ((self.bits >> 23) & 0x01) != 0;
MR55R { bits }
}
#[doc = "Bit 24 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr56(&self) -> MR56R {
let bits = ((self.bits >> 24) & 0x01) != 0;
MR56R { bits }
}
#[doc = "Bit 25 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr57(&self) -> MR57R {
let bits = ((self.bits >> 25) & 0x01) != 0;
MR57R { bits }
}
#[doc = "Bit 26 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr58(&self) -> MR58R {
let bits = ((self.bits >> 26) & 0x01) != 0;
MR58R { bits }
}
#[doc = "Bit 27 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr59(&self) -> MR59R {
let bits = ((self.bits >> 27) & 0x01) != 0;
MR59R { bits }
}
#[doc = "Bit 28 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr60(&self) -> MR60R {
let bits = ((self.bits >> 28) & 0x01) != 0;
MR60R { bits }
}
#[doc = "Bit 29 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr61(&self) -> MR61R {
let bits = ((self.bits >> 29) & 0x01) != 0;
MR61R { bits }
}
#[doc = "Bit 30 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr62(&self) -> MR62R {
let bits = ((self.bits >> 30) & 0x01) != 0;
MR62R { bits }
}
#[doc = "Bit 31 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr63(&self) -> MR63R {
let bits = ((self.bits >> 31) & 0x01) != 0;
MR63R { bits }
}
}
impl W {
#[doc = r"Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bit 0 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr32(&mut self) -> _MR32W {
_MR32W { w: self }
}
#[doc = "Bit 1 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr33(&mut self) -> _MR33W {
_MR33W { w: self }
}
#[doc = "Bit 2 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr34(&mut self) -> _MR34W {
_MR34W { w: self }
}
#[doc = "Bit 3 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr35(&mut self) -> _MR35W {
_MR35W { w: self }
}
#[doc = "Bit 4 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr36(&mut self) -> _MR36W {
_MR36W { w: self }
}
#[doc = "Bit 5 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr37(&mut self) -> _MR37W {
_MR37W { w: self }
}
#[doc = "Bit 6 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr38(&mut self) -> _MR38W {
_MR38W { w: self }
}
#[doc = "Bit 7 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr39(&mut self) -> _MR39W {
_MR39W { w: self }
}
#[doc = "Bit 8 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr40(&mut self) -> _MR40W {
_MR40W { w: self }
}
#[doc = "Bit 9 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr41(&mut self) -> _MR41W {
_MR41W { w: self }
}
#[doc = "Bit 10 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr42(&mut self) -> _MR42W {
_MR42W { w: self }
}
#[doc = "Bit 11 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr43(&mut self) -> _MR43W {
_MR43W { w: self }
}
#[doc = "Bit 12 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr44(&mut self) -> _MR44W {
_MR44W { w: self }
}
#[doc = "Bit 14 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr46(&mut self) -> _MR46W {
_MR46W { w: self }
}
#[doc = "Bit 15 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr47(&mut self) -> _MR47W {
_MR47W { w: self }
}
#[doc = "Bit 16 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr48(&mut self) -> _MR48W {
_MR48W { w: self }
}
#[doc = "Bit 17 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr49(&mut self) -> _MR49W {
_MR49W { w: self }
}
#[doc = "Bit 18 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr50(&mut self) -> _MR50W {
_MR50W { w: self }
}
#[doc = "Bit 19 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr51(&mut self) -> _MR51W {
_MR51W { w: self }
}
#[doc = "Bit 20 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr52(&mut self) -> _MR52W {
_MR52W { w: self }
}
#[doc = "Bit 21 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr53(&mut self) -> _MR53W {
_MR53W { w: self }
}
#[doc = "Bit 22 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr54(&mut self) -> _MR54W {
_MR54W { w: self }
}
#[doc = "Bit 23 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr55(&mut self) -> _MR55W {
_MR55W { w: self }
}
#[doc = "Bit 24 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr56(&mut self) -> _MR56W {
_MR56W { w: self }
}
#[doc = "Bit 25 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr57(&mut self) -> _MR57W {
_MR57W { w: self }
}
#[doc = "Bit 26 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr58(&mut self) -> _MR58W {
_MR58W { w: self }
}
#[doc = "Bit 27 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr59(&mut self) -> _MR59W {
_MR59W { w: self }
}
#[doc = "Bit 28 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr60(&mut self) -> _MR60W {
_MR60W { w: self }
}
#[doc = "Bit 29 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr61(&mut self) -> _MR61W {
_MR61W { w: self }
}
#[doc = "Bit 30 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr62(&mut self) -> _MR62W {
_MR62W { w: self }
}
#[doc = "Bit 31 - CPU Interrupt Mask on Direct Event input x+32"]
#[inline(always)]
pub fn mr63(&mut self) -> _MR63W {
_MR63W { w: self }
}
}