#[doc = "Reader of register MPCBB1_VCTR11"]
pub type R = crate::R<u32, super::MPCBB1_VCTR11>;
#[doc = "Writer for register MPCBB1_VCTR11"]
pub type W = crate::W<u32, super::MPCBB1_VCTR11>;
#[doc = "Register MPCBB1_VCTR11 `reset()`'s with value 0"]
impl crate::ResetValue for super::MPCBB1_VCTR11 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `B352`"]
pub type B352_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B352`"]
pub struct B352_W<'a> {
w: &'a mut W,
}
impl<'a> B352_W<'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 = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `B353`"]
pub type B353_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B353`"]
pub struct B353_W<'a> {
w: &'a mut W,
}
impl<'a> B353_W<'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 = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `B354`"]
pub type B354_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B354`"]
pub struct B354_W<'a> {
w: &'a mut W,
}
impl<'a> B354_W<'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 = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `B355`"]
pub type B355_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B355`"]
pub struct B355_W<'a> {
w: &'a mut W,
}
impl<'a> B355_W<'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 = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `B356`"]
pub type B356_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B356`"]
pub struct B356_W<'a> {
w: &'a mut W,
}
impl<'a> B356_W<'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 = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `B357`"]
pub type B357_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B357`"]
pub struct B357_W<'a> {
w: &'a mut W,
}
impl<'a> B357_W<'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 = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `B358`"]
pub type B358_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B358`"]
pub struct B358_W<'a> {
w: &'a mut W,
}
impl<'a> B358_W<'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 = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Reader of field `B359`"]
pub type B359_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B359`"]
pub struct B359_W<'a> {
w: &'a mut W,
}
impl<'a> B359_W<'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 = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Reader of field `B360`"]
pub type B360_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B360`"]
pub struct B360_W<'a> {
w: &'a mut W,
}
impl<'a> B360_W<'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 = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `B361`"]
pub type B361_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B361`"]
pub struct B361_W<'a> {
w: &'a mut W,
}
impl<'a> B361_W<'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 = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `B362`"]
pub type B362_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B362`"]
pub struct B362_W<'a> {
w: &'a mut W,
}
impl<'a> B362_W<'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 = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Reader of field `B363`"]
pub type B363_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B363`"]
pub struct B363_W<'a> {
w: &'a mut W,
}
impl<'a> B363_W<'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 = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
#[doc = "Reader of field `B364`"]
pub type B364_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B364`"]
pub struct B364_W<'a> {
w: &'a mut W,
}
impl<'a> B364_W<'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 = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Reader of field `B365`"]
pub type B365_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B365`"]
pub struct B365_W<'a> {
w: &'a mut W,
}
impl<'a> B365_W<'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 = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
self.w
}
}
#[doc = "Reader of field `B366`"]
pub type B366_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B366`"]
pub struct B366_W<'a> {
w: &'a mut W,
}
impl<'a> B366_W<'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 = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
self.w
}
}
#[doc = "Reader of field `B367`"]
pub type B367_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B367`"]
pub struct B367_W<'a> {
w: &'a mut W,
}
impl<'a> B367_W<'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 = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
self.w
}
}
#[doc = "Reader of field `B368`"]
pub type B368_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B368`"]
pub struct B368_W<'a> {
w: &'a mut W,
}
impl<'a> B368_W<'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 = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Reader of field `B369`"]
pub type B369_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B369`"]
pub struct B369_W<'a> {
w: &'a mut W,
}
impl<'a> B369_W<'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 = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
self.w
}
}
#[doc = "Reader of field `B370`"]
pub type B370_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B370`"]
pub struct B370_W<'a> {
w: &'a mut W,
}
impl<'a> B370_W<'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 = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
self.w
}
}
#[doc = "Reader of field `B371`"]
pub type B371_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B371`"]
pub struct B371_W<'a> {
w: &'a mut W,
}
impl<'a> B371_W<'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 = (self.w.bits & !(0x01 << 19)) | (((value as u32) & 0x01) << 19);
self.w
}
}
#[doc = "Reader of field `B372`"]
pub type B372_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B372`"]
pub struct B372_W<'a> {
w: &'a mut W,
}
impl<'a> B372_W<'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 = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
self.w
}
}
#[doc = "Reader of field `B373`"]
pub type B373_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B373`"]
pub struct B373_W<'a> {
w: &'a mut W,
}
impl<'a> B373_W<'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 = (self.w.bits & !(0x01 << 21)) | (((value as u32) & 0x01) << 21);
self.w
}
}
#[doc = "Reader of field `B374`"]
pub type B374_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B374`"]
pub struct B374_W<'a> {
w: &'a mut W,
}
impl<'a> B374_W<'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 = (self.w.bits & !(0x01 << 22)) | (((value as u32) & 0x01) << 22);
self.w
}
}
#[doc = "Reader of field `B375`"]
pub type B375_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B375`"]
pub struct B375_W<'a> {
w: &'a mut W,
}
impl<'a> B375_W<'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 = (self.w.bits & !(0x01 << 23)) | (((value as u32) & 0x01) << 23);
self.w
}
}
#[doc = "Reader of field `B376`"]
pub type B376_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B376`"]
pub struct B376_W<'a> {
w: &'a mut W,
}
impl<'a> B376_W<'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 = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
self.w
}
}
#[doc = "Reader of field `B377`"]
pub type B377_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B377`"]
pub struct B377_W<'a> {
w: &'a mut W,
}
impl<'a> B377_W<'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 = (self.w.bits & !(0x01 << 25)) | (((value as u32) & 0x01) << 25);
self.w
}
}
#[doc = "Reader of field `B378`"]
pub type B378_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B378`"]
pub struct B378_W<'a> {
w: &'a mut W,
}
impl<'a> B378_W<'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 = (self.w.bits & !(0x01 << 26)) | (((value as u32) & 0x01) << 26);
self.w
}
}
#[doc = "Reader of field `B379`"]
pub type B379_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B379`"]
pub struct B379_W<'a> {
w: &'a mut W,
}
impl<'a> B379_W<'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 = (self.w.bits & !(0x01 << 27)) | (((value as u32) & 0x01) << 27);
self.w
}
}
#[doc = "Reader of field `B380`"]
pub type B380_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B380`"]
pub struct B380_W<'a> {
w: &'a mut W,
}
impl<'a> B380_W<'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 = (self.w.bits & !(0x01 << 28)) | (((value as u32) & 0x01) << 28);
self.w
}
}
#[doc = "Reader of field `B381`"]
pub type B381_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B381`"]
pub struct B381_W<'a> {
w: &'a mut W,
}
impl<'a> B381_W<'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 = (self.w.bits & !(0x01 << 29)) | (((value as u32) & 0x01) << 29);
self.w
}
}
#[doc = "Reader of field `B382`"]
pub type B382_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B382`"]
pub struct B382_W<'a> {
w: &'a mut W,
}
impl<'a> B382_W<'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 = (self.w.bits & !(0x01 << 30)) | (((value as u32) & 0x01) << 30);
self.w
}
}
#[doc = "Reader of field `B383`"]
pub type B383_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `B383`"]
pub struct B383_W<'a> {
w: &'a mut W,
}
impl<'a> B383_W<'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 = (self.w.bits & !(0x01 << 31)) | (((value as u32) & 0x01) << 31);
self.w
}
}
impl R {
#[doc = "Bit 0 - B352"]
#[inline(always)]
pub fn b352(&self) -> B352_R {
B352_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - B353"]
#[inline(always)]
pub fn b353(&self) -> B353_R {
B353_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - B354"]
#[inline(always)]
pub fn b354(&self) -> B354_R {
B354_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - B355"]
#[inline(always)]
pub fn b355(&self) -> B355_R {
B355_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - B356"]
#[inline(always)]
pub fn b356(&self) -> B356_R {
B356_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - B357"]
#[inline(always)]
pub fn b357(&self) -> B357_R {
B357_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - B358"]
#[inline(always)]
pub fn b358(&self) -> B358_R {
B358_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - B359"]
#[inline(always)]
pub fn b359(&self) -> B359_R {
B359_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - B360"]
#[inline(always)]
pub fn b360(&self) -> B360_R {
B360_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - B361"]
#[inline(always)]
pub fn b361(&self) -> B361_R {
B361_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - B362"]
#[inline(always)]
pub fn b362(&self) -> B362_R {
B362_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - B363"]
#[inline(always)]
pub fn b363(&self) -> B363_R {
B363_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 12 - B364"]
#[inline(always)]
pub fn b364(&self) -> B364_R {
B364_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 13 - B365"]
#[inline(always)]
pub fn b365(&self) -> B365_R {
B365_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 14 - B366"]
#[inline(always)]
pub fn b366(&self) -> B366_R {
B366_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 15 - B367"]
#[inline(always)]
pub fn b367(&self) -> B367_R {
B367_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 16 - B368"]
#[inline(always)]
pub fn b368(&self) -> B368_R {
B368_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - B369"]
#[inline(always)]
pub fn b369(&self) -> B369_R {
B369_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - B370"]
#[inline(always)]
pub fn b370(&self) -> B370_R {
B370_R::new(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 19 - B371"]
#[inline(always)]
pub fn b371(&self) -> B371_R {
B371_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 20 - B372"]
#[inline(always)]
pub fn b372(&self) -> B372_R {
B372_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 21 - B373"]
#[inline(always)]
pub fn b373(&self) -> B373_R {
B373_R::new(((self.bits >> 21) & 0x01) != 0)
}
#[doc = "Bit 22 - B374"]
#[inline(always)]
pub fn b374(&self) -> B374_R {
B374_R::new(((self.bits >> 22) & 0x01) != 0)
}
#[doc = "Bit 23 - B375"]
#[inline(always)]
pub fn b375(&self) -> B375_R {
B375_R::new(((self.bits >> 23) & 0x01) != 0)
}
#[doc = "Bit 24 - B376"]
#[inline(always)]
pub fn b376(&self) -> B376_R {
B376_R::new(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 25 - B377"]
#[inline(always)]
pub fn b377(&self) -> B377_R {
B377_R::new(((self.bits >> 25) & 0x01) != 0)
}
#[doc = "Bit 26 - B378"]
#[inline(always)]
pub fn b378(&self) -> B378_R {
B378_R::new(((self.bits >> 26) & 0x01) != 0)
}
#[doc = "Bit 27 - B379"]
#[inline(always)]
pub fn b379(&self) -> B379_R {
B379_R::new(((self.bits >> 27) & 0x01) != 0)
}
#[doc = "Bit 28 - B380"]
#[inline(always)]
pub fn b380(&self) -> B380_R {
B380_R::new(((self.bits >> 28) & 0x01) != 0)
}
#[doc = "Bit 29 - B381"]
#[inline(always)]
pub fn b381(&self) -> B381_R {
B381_R::new(((self.bits >> 29) & 0x01) != 0)
}
#[doc = "Bit 30 - B382"]
#[inline(always)]
pub fn b382(&self) -> B382_R {
B382_R::new(((self.bits >> 30) & 0x01) != 0)
}
#[doc = "Bit 31 - B383"]
#[inline(always)]
pub fn b383(&self) -> B383_R {
B383_R::new(((self.bits >> 31) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - B352"]
#[inline(always)]
pub fn b352(&mut self) -> B352_W {
B352_W { w: self }
}
#[doc = "Bit 1 - B353"]
#[inline(always)]
pub fn b353(&mut self) -> B353_W {
B353_W { w: self }
}
#[doc = "Bit 2 - B354"]
#[inline(always)]
pub fn b354(&mut self) -> B354_W {
B354_W { w: self }
}
#[doc = "Bit 3 - B355"]
#[inline(always)]
pub fn b355(&mut self) -> B355_W {
B355_W { w: self }
}
#[doc = "Bit 4 - B356"]
#[inline(always)]
pub fn b356(&mut self) -> B356_W {
B356_W { w: self }
}
#[doc = "Bit 5 - B357"]
#[inline(always)]
pub fn b357(&mut self) -> B357_W {
B357_W { w: self }
}
#[doc = "Bit 6 - B358"]
#[inline(always)]
pub fn b358(&mut self) -> B358_W {
B358_W { w: self }
}
#[doc = "Bit 7 - B359"]
#[inline(always)]
pub fn b359(&mut self) -> B359_W {
B359_W { w: self }
}
#[doc = "Bit 8 - B360"]
#[inline(always)]
pub fn b360(&mut self) -> B360_W {
B360_W { w: self }
}
#[doc = "Bit 9 - B361"]
#[inline(always)]
pub fn b361(&mut self) -> B361_W {
B361_W { w: self }
}
#[doc = "Bit 10 - B362"]
#[inline(always)]
pub fn b362(&mut self) -> B362_W {
B362_W { w: self }
}
#[doc = "Bit 11 - B363"]
#[inline(always)]
pub fn b363(&mut self) -> B363_W {
B363_W { w: self }
}
#[doc = "Bit 12 - B364"]
#[inline(always)]
pub fn b364(&mut self) -> B364_W {
B364_W { w: self }
}
#[doc = "Bit 13 - B365"]
#[inline(always)]
pub fn b365(&mut self) -> B365_W {
B365_W { w: self }
}
#[doc = "Bit 14 - B366"]
#[inline(always)]
pub fn b366(&mut self) -> B366_W {
B366_W { w: self }
}
#[doc = "Bit 15 - B367"]
#[inline(always)]
pub fn b367(&mut self) -> B367_W {
B367_W { w: self }
}
#[doc = "Bit 16 - B368"]
#[inline(always)]
pub fn b368(&mut self) -> B368_W {
B368_W { w: self }
}
#[doc = "Bit 17 - B369"]
#[inline(always)]
pub fn b369(&mut self) -> B369_W {
B369_W { w: self }
}
#[doc = "Bit 18 - B370"]
#[inline(always)]
pub fn b370(&mut self) -> B370_W {
B370_W { w: self }
}
#[doc = "Bit 19 - B371"]
#[inline(always)]
pub fn b371(&mut self) -> B371_W {
B371_W { w: self }
}
#[doc = "Bit 20 - B372"]
#[inline(always)]
pub fn b372(&mut self) -> B372_W {
B372_W { w: self }
}
#[doc = "Bit 21 - B373"]
#[inline(always)]
pub fn b373(&mut self) -> B373_W {
B373_W { w: self }
}
#[doc = "Bit 22 - B374"]
#[inline(always)]
pub fn b374(&mut self) -> B374_W {
B374_W { w: self }
}
#[doc = "Bit 23 - B375"]
#[inline(always)]
pub fn b375(&mut self) -> B375_W {
B375_W { w: self }
}
#[doc = "Bit 24 - B376"]
#[inline(always)]
pub fn b376(&mut self) -> B376_W {
B376_W { w: self }
}
#[doc = "Bit 25 - B377"]
#[inline(always)]
pub fn b377(&mut self) -> B377_W {
B377_W { w: self }
}
#[doc = "Bit 26 - B378"]
#[inline(always)]
pub fn b378(&mut self) -> B378_W {
B378_W { w: self }
}
#[doc = "Bit 27 - B379"]
#[inline(always)]
pub fn b379(&mut self) -> B379_W {
B379_W { w: self }
}
#[doc = "Bit 28 - B380"]
#[inline(always)]
pub fn b380(&mut self) -> B380_W {
B380_W { w: self }
}
#[doc = "Bit 29 - B381"]
#[inline(always)]
pub fn b381(&mut self) -> B381_W {
B381_W { w: self }
}
#[doc = "Bit 30 - B382"]
#[inline(always)]
pub fn b382(&mut self) -> B382_W {
B382_W { w: self }
}
#[doc = "Bit 31 - B383"]
#[inline(always)]
pub fn b383(&mut self) -> B383_W {
B383_W { w: self }
}
}